1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
32 #include "diagnostic.h"
35 /* The bindings for a particular name in a particular scope. */
37 struct scope_binding
{
41 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
43 static cxx_scope
*innermost_nonclass_level (void);
44 static tree
select_decl (const struct scope_binding
*, int);
45 static cxx_binding
*binding_for_name (cxx_scope
*, tree
);
46 static tree
lookup_name_innermost_nonclass_level (tree
);
47 static tree
push_overloaded_decl (tree
, int, 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
;
64 /* Compute the chain index of a binding_entry given the HASH value of its
65 name and the total COUNT of chains. COUNT is assumed to be a power
68 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
70 /* A free list of "binding_entry"s awaiting for re-use. */
72 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
74 /* Create a binding_entry object for (NAME, TYPE). */
76 static inline binding_entry
77 binding_entry_make (tree name
, tree type
)
81 if (free_binding_entry
)
83 entry
= free_binding_entry
;
84 free_binding_entry
= entry
->chain
;
87 entry
= GGC_NEW (struct binding_entry_s
);
96 /* Put ENTRY back on the free list. */
99 binding_entry_free (binding_entry entry
)
103 entry
->chain
= free_binding_entry
;
104 free_binding_entry
= entry
;
108 /* The datatype used to implement the mapping from names to types at
110 struct binding_table_s
GTY(())
112 /* Array of chains of "binding_entry"s */
113 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
115 /* The number of chains in this table. This is the length of the
116 the member "chain" considered as an array. */
119 /* Number of "binding_entry"s in this table. */
123 /* Construct TABLE with an initial CHAIN_COUNT. */
126 binding_table_construct (binding_table table
, size_t chain_count
)
128 table
->chain_count
= chain_count
;
129 table
->entry_count
= 0;
130 table
->chain
= GGC_CNEWVEC (binding_entry
, table
->chain_count
);
133 /* Make TABLE's entries ready for reuse. */
136 binding_table_free (binding_table table
)
144 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
146 binding_entry temp
= table
->chain
[i
];
149 binding_entry entry
= temp
;
151 binding_entry_free (entry
);
153 table
->chain
[i
] = NULL
;
155 table
->entry_count
= 0;
159 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
161 static inline binding_table
162 binding_table_new (size_t chain_count
)
164 binding_table table
= GGC_NEW (struct binding_table_s
);
166 binding_table_construct (table
, chain_count
);
170 /* Expand TABLE to twice its current chain_count. */
173 binding_table_expand (binding_table table
)
175 const size_t old_chain_count
= table
->chain_count
;
176 const size_t old_entry_count
= table
->entry_count
;
177 const size_t new_chain_count
= 2 * old_chain_count
;
178 binding_entry
*old_chains
= table
->chain
;
181 binding_table_construct (table
, new_chain_count
);
182 for (i
= 0; i
< old_chain_count
; ++i
)
184 binding_entry entry
= old_chains
[i
];
185 for (; entry
!= NULL
; entry
= old_chains
[i
])
187 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
188 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
190 old_chains
[i
] = entry
->chain
;
191 entry
->chain
= table
->chain
[j
];
192 table
->chain
[j
] = entry
;
195 table
->entry_count
= old_entry_count
;
198 /* Insert a binding for NAME to TYPE into TABLE. */
201 binding_table_insert (binding_table table
, tree name
, tree type
)
203 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
204 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
205 binding_entry entry
= binding_entry_make (name
, type
);
207 entry
->chain
= table
->chain
[i
];
208 table
->chain
[i
] = entry
;
209 ++table
->entry_count
;
211 if (3 * table
->chain_count
< 5 * table
->entry_count
)
212 binding_table_expand (table
);
215 /* Return the binding_entry, if any, that maps NAME. */
218 binding_table_find (binding_table table
, tree name
)
220 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
221 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
223 while (entry
!= NULL
&& entry
->name
!= name
)
224 entry
= entry
->chain
;
229 /* Apply PROC -- with DATA -- to all entries in TABLE. */
232 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
234 const size_t chain_count
= table
->chain_count
;
237 for (i
= 0; i
< chain_count
; ++i
)
239 binding_entry entry
= table
->chain
[i
];
240 for (; entry
!= NULL
; entry
= entry
->chain
)
245 #ifndef ENABLE_SCOPE_CHECKING
246 # define ENABLE_SCOPE_CHECKING 0
248 # define ENABLE_SCOPE_CHECKING 1
251 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
253 static GTY((deletable
)) cxx_binding
*free_bindings
;
255 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
259 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
261 binding
->value
= value
;
262 binding
->type
= type
;
263 binding
->previous
= NULL
;
266 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
269 cxx_binding_make (tree value
, tree type
)
271 cxx_binding
*binding
;
274 binding
= free_bindings
;
275 free_bindings
= binding
->previous
;
278 binding
= GGC_NEW (cxx_binding
);
280 cxx_binding_init (binding
, value
, type
);
285 /* Put BINDING back on the free list. */
288 cxx_binding_free (cxx_binding
*binding
)
290 binding
->scope
= NULL
;
291 binding
->previous
= free_bindings
;
292 free_bindings
= binding
;
295 /* Create a new binding for NAME (with the indicated VALUE and TYPE
296 bindings) in the class scope indicated by SCOPE. */
299 new_class_binding (tree name
, tree value
, tree type
, cxx_scope
*scope
)
301 cp_class_binding
*cb
;
302 cxx_binding
*binding
;
304 if (VEC_length (cp_class_binding
, scope
->class_shadowed
))
306 cp_class_binding
*old_base
;
307 old_base
= VEC_index (cp_class_binding
, scope
->class_shadowed
, 0);
308 if (VEC_reserve (cp_class_binding
, gc
, scope
->class_shadowed
, 1))
310 /* Fixup the current bindings, as they might have moved. */
314 VEC_iterate (cp_class_binding
, scope
->class_shadowed
, i
, cb
);
318 b
= &IDENTIFIER_BINDING (cb
->identifier
);
319 while (*b
!= &old_base
[i
].base
)
320 b
= &((*b
)->previous
);
324 cb
= VEC_quick_push (cp_class_binding
, scope
->class_shadowed
, NULL
);
327 cb
= VEC_safe_push (cp_class_binding
, gc
, scope
->class_shadowed
, NULL
);
329 cb
->identifier
= name
;
331 binding
->scope
= scope
;
332 cxx_binding_init (binding
, value
, type
);
336 /* Make DECL the innermost binding for ID. The LEVEL is the binding
337 level at which this declaration is being bound. */
340 push_binding (tree id
, tree decl
, cxx_scope
* level
)
342 cxx_binding
*binding
;
344 if (level
!= class_binding_level
)
346 binding
= cxx_binding_make (decl
, NULL_TREE
);
347 binding
->scope
= level
;
350 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
352 /* Now, fill in the binding information. */
353 binding
->previous
= IDENTIFIER_BINDING (id
);
354 INHERITED_VALUE_BINDING_P (binding
) = 0;
355 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
357 /* And put it on the front of the list of bindings for ID. */
358 IDENTIFIER_BINDING (id
) = binding
;
361 /* Remove the binding for DECL which should be the innermost binding
365 pop_binding (tree id
, tree decl
)
367 cxx_binding
*binding
;
370 /* It's easiest to write the loops that call this function without
371 checking whether or not the entities involved have names. We
372 get here for such an entity. */
375 /* Get the innermost binding for ID. */
376 binding
= IDENTIFIER_BINDING (id
);
378 /* The name should be bound. */
379 gcc_assert (binding
!= NULL
);
381 /* The DECL will be either the ordinary binding or the type
382 binding for this identifier. Remove that binding. */
383 if (binding
->value
== decl
)
384 binding
->value
= NULL_TREE
;
387 gcc_assert (binding
->type
== decl
);
388 binding
->type
= NULL_TREE
;
391 if (!binding
->value
&& !binding
->type
)
393 /* We're completely done with the innermost binding for this
394 identifier. Unhook it from the list of bindings. */
395 IDENTIFIER_BINDING (id
) = binding
->previous
;
397 /* Add it to the free list. */
398 cxx_binding_free (binding
);
402 /* BINDING records an existing declaration for a name in the current scope.
403 But, DECL is another declaration for that same identifier in the
404 same scope. This is the `struct stat' hack whereby a non-typedef
405 class name or enum-name can be bound at the same level as some other
409 A class name (9.1) or enumeration name (7.2) can be hidden by the
410 name of an object, function, or enumerator declared in the same scope.
411 If a class or enumeration name and an object, function, or enumerator
412 are declared in the same scope (in any order) with the same name, the
413 class or enumeration name is hidden wherever the object, function, or
414 enumerator name is visible.
416 It's the responsibility of the caller to check that
417 inserting this name is valid here. Returns nonzero if the new binding
421 supplement_binding (cxx_binding
*binding
, tree decl
)
423 tree bval
= binding
->value
;
426 timevar_push (TV_NAME_LOOKUP
);
427 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
428 /* The new name is the type name. */
429 binding
->type
= decl
;
430 else if (/* BVAL is null when push_class_level_binding moves an
431 inherited type-binding out of the way to make room for a
432 new value binding. */
434 /* BVAL is error_mark_node when DECL's name has been used
435 in a non-class scope prior declaration. In that case,
436 we should have already issued a diagnostic; for graceful
437 error recovery purpose, pretend this was the intended
438 declaration for that name. */
439 || bval
== error_mark_node
440 /* If BVAL is anticipated but has not yet been declared,
441 pretend it is not there at all. */
442 || (TREE_CODE (bval
) == FUNCTION_DECL
443 && DECL_ANTICIPATED (bval
)
444 && !DECL_HIDDEN_FRIEND_P (bval
)))
445 binding
->value
= decl
;
446 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
448 /* The old binding was a type name. It was placed in
449 VALUE field because it was thought, at the point it was
450 declared, to be the only entity with such a name. Move the
451 type name into the type slot; it is now hidden by the new
453 binding
->type
= bval
;
454 binding
->value
= decl
;
455 binding
->value_is_inherited
= false;
457 else if (TREE_CODE (bval
) == TYPE_DECL
458 && TREE_CODE (decl
) == TYPE_DECL
459 && DECL_NAME (decl
) == DECL_NAME (bval
)
460 && binding
->scope
->kind
!= sk_class
461 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
462 /* If either type involves template parameters, we must
463 wait until instantiation. */
464 || uses_template_parms (TREE_TYPE (decl
))
465 || uses_template_parms (TREE_TYPE (bval
))))
466 /* We have two typedef-names, both naming the same type to have
467 the same name. In general, this is OK because of:
471 In a given scope, a typedef specifier can be used to redefine
472 the name of any type declared in that scope to refer to the
473 type to which it already refers.
475 However, in class scopes, this rule does not apply due to the
476 stricter language in [class.mem] prohibiting redeclarations of
479 /* There can be two block-scope declarations of the same variable,
480 so long as they are `extern' declarations. However, there cannot
481 be two declarations of the same static data member:
485 A member shall not be declared twice in the
486 member-specification. */
487 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
488 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
489 && !DECL_CLASS_SCOPE_P (decl
))
491 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
494 else if (TREE_CODE (decl
) == NAMESPACE_DECL
495 && TREE_CODE (bval
) == NAMESPACE_DECL
496 && DECL_NAMESPACE_ALIAS (decl
)
497 && DECL_NAMESPACE_ALIAS (bval
)
498 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
501 In a declarative region, a namespace-alias-definition can be
502 used to redefine a namespace-alias declared in that declarative
503 region to refer only to the namespace to which it already
508 error ("declaration of %q#D", decl
);
509 error ("conflicts with previous declaration %q+#D", bval
);
513 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
516 /* Add DECL to the list of things declared in B. */
519 add_decl_to_level (tree decl
, cxx_scope
*b
)
521 if (TREE_CODE (decl
) == NAMESPACE_DECL
522 && !DECL_NAMESPACE_ALIAS (decl
))
524 TREE_CHAIN (decl
) = b
->namespaces
;
525 b
->namespaces
= decl
;
527 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
529 TREE_CHAIN (decl
) = b
->vtables
;
534 /* We build up the list in reverse order, and reverse it later if
536 TREE_CHAIN (decl
) = b
->names
;
540 /* If appropriate, add decl to separate list of statics. We
541 include extern variables because they might turn out to be
542 static later. It's OK for this list to contain a few false
544 if (b
->kind
== sk_namespace
)
545 if ((TREE_CODE (decl
) == VAR_DECL
546 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
547 || (TREE_CODE (decl
) == FUNCTION_DECL
548 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
549 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
553 /* Record a decl-node X as belonging to the current lexical scope.
554 Check for errors (such as an incompatible declaration for the same
555 name already seen in the same scope). IS_FRIEND is true if X is
556 declared as a friend.
558 Returns either X or an old decl for the same name.
559 If an old decl is returned, it may have been smashed
560 to agree with what X says. */
563 pushdecl_maybe_friend (tree x
, bool is_friend
)
567 int need_new_binding
;
569 timevar_push (TV_NAME_LOOKUP
);
571 need_new_binding
= 1;
573 if (DECL_TEMPLATE_PARM_P (x
))
574 /* Template parameters have no context; they are not X::T even
575 when declared within a class or namespace. */
579 if (current_function_decl
&& x
!= current_function_decl
580 /* A local declaration for a function doesn't constitute
582 && TREE_CODE (x
) != FUNCTION_DECL
583 /* A local declaration for an `extern' variable is in the
584 scope of the current namespace, not the current
586 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
587 && !DECL_CONTEXT (x
))
588 DECL_CONTEXT (x
) = current_function_decl
;
590 /* If this is the declaration for a namespace-scope function,
591 but the declaration itself is in a local scope, mark the
593 if (TREE_CODE (x
) == FUNCTION_DECL
594 && DECL_NAMESPACE_SCOPE_P (x
)
595 && current_function_decl
596 && x
!= current_function_decl
)
597 DECL_LOCAL_FUNCTION_P (x
) = 1;
600 name
= DECL_NAME (x
);
603 int different_binding_level
= 0;
605 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
606 name
= TREE_OPERAND (name
, 0);
608 /* In case this decl was explicitly namespace-qualified, look it
609 up in its namespace context. */
610 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
611 t
= namespace_binding (name
, DECL_CONTEXT (x
));
613 t
= lookup_name_innermost_nonclass_level (name
);
615 /* [basic.link] If there is a visible declaration of an entity
616 with linkage having the same name and type, ignoring entities
617 declared outside the innermost enclosing namespace scope, the
618 block scope declaration declares that same entity and
619 receives the linkage of the previous declaration. */
620 if (! t
&& current_function_decl
&& x
!= current_function_decl
621 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
622 && DECL_EXTERNAL (x
))
624 /* Look in block scope. */
625 t
= innermost_non_namespace_value (name
);
626 /* Or in the innermost namespace. */
628 t
= namespace_binding (name
, DECL_CONTEXT (x
));
629 /* Does it have linkage? Note that if this isn't a DECL, it's an
630 OVERLOAD, which is OK. */
631 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
634 different_binding_level
= 1;
637 /* If we are declaring a function, and the result of name-lookup
638 was an OVERLOAD, look for an overloaded instance that is
639 actually the same as the function we are declaring. (If
640 there is one, we have to merge our declaration with the
641 previous declaration.) */
642 if (t
&& TREE_CODE (t
) == OVERLOAD
)
646 if (TREE_CODE (x
) == FUNCTION_DECL
)
647 for (match
= t
; match
; match
= OVL_NEXT (match
))
649 if (decls_match (OVL_CURRENT (match
), x
))
653 /* Just choose one. */
657 t
= OVL_CURRENT (match
);
662 if (t
&& t
!= error_mark_node
)
664 if (different_binding_level
)
666 if (decls_match (x
, t
))
667 /* The standard only says that the local extern
668 inherits linkage from the previous decl; in
669 particular, default args are not shared. We must
670 also tell cgraph to treat these decls as the same,
671 or we may neglect to emit an "unused" static - we
672 do this by making the DECL_UIDs equal, which should
673 be viewed as a kludge. FIXME. */
675 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
676 DECL_UID (x
) = DECL_UID (t
);
679 else if (TREE_CODE (t
) == PARM_DECL
)
681 gcc_assert (DECL_CONTEXT (t
));
683 /* Check for duplicate params. */
684 if (duplicate_decls (x
, t
, is_friend
))
685 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
687 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
688 || DECL_FUNCTION_TEMPLATE_P (x
))
689 && is_overloaded_fn (t
))
690 /* Don't do anything just yet. */;
691 else if (t
== wchar_decl_node
)
693 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
694 pedwarn ("redeclaration of %<wchar_t%> as %qT",
697 /* Throw away the redeclaration. */
698 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
702 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
704 /* If the redeclaration failed, we can stop at this
706 if (olddecl
== error_mark_node
)
707 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
711 if (TREE_CODE (t
) == TYPE_DECL
)
712 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
713 else if (TREE_CODE (t
) == FUNCTION_DECL
)
714 check_default_args (t
);
716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
718 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
720 /* A redeclaration of main, but not a duplicate of the
725 This function shall not be overloaded. */
726 error ("invalid redeclaration of %q+D", t
);
728 /* We don't try to push this declaration since that
730 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
735 check_template_shadow (x
);
737 /* If this is a function conjured up by the backend, massage it
738 so it looks friendly. */
739 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
741 retrofit_lang_decl (x
);
742 SET_DECL_LANGUAGE (x
, lang_c
);
745 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
747 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
749 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
750 if (!namespace_bindings_p ())
751 /* We do not need to create a binding for this name;
752 push_overloaded_decl will have already done so if
754 need_new_binding
= 0;
756 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
758 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
760 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
764 /* If declaring a type as a typedef, copy the type (unless we're
765 at line 0), and install this TYPE_DECL as the new type's typedef
766 name. See the extensive comment in ../c-decl.c (pushdecl). */
767 if (TREE_CODE (x
) == TYPE_DECL
)
769 tree type
= TREE_TYPE (x
);
770 if (DECL_IS_BUILTIN (x
))
772 if (TYPE_NAME (type
) == 0)
773 TYPE_NAME (type
) = x
;
775 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
776 /* We don't want to copy the type when all we're
777 doing is making a TYPE_DECL for the purposes of
779 && (!TYPE_NAME (type
)
780 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
782 DECL_ORIGINAL_TYPE (x
) = type
;
783 type
= build_variant_type_copy (type
);
784 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
785 TYPE_NAME (type
) = x
;
786 TREE_TYPE (x
) = type
;
789 if (type
!= error_mark_node
791 && TYPE_IDENTIFIER (type
))
792 set_identifier_type_value (DECL_NAME (x
), x
);
795 /* Multiple external decls of the same identifier ought to match.
797 We get warnings about inline functions where they are defined.
798 We get warnings about other functions from push_overloaded_decl.
800 Avoid duplicate warnings where they are used. */
801 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
805 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
806 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
807 decl
= OVL_FUNCTION (decl
);
809 if (decl
&& decl
!= error_mark_node
810 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
811 /* If different sort of thing, we already gave an error. */
812 && TREE_CODE (decl
) == TREE_CODE (x
)
813 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
815 pedwarn ("type mismatch with previous external decl of %q#D", x
);
816 pedwarn ("previous external decl of %q+#D", decl
);
820 if (TREE_CODE (x
) == FUNCTION_DECL
822 && !flag_friend_injection
)
824 /* This is a new declaration of a friend function, so hide
825 it from ordinary function lookup. */
826 DECL_ANTICIPATED (x
) = 1;
827 DECL_HIDDEN_FRIEND_P (x
) = 1;
830 /* This name is new in its binding level.
831 Install the new declaration and return it. */
832 if (namespace_bindings_p ())
834 /* Install a global value. */
836 /* If the first global decl has external linkage,
837 warn if we later see static one. */
838 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
839 TREE_PUBLIC (name
) = 1;
841 /* Bind the name for the entity. */
842 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
844 && (TREE_CODE (x
) == TYPE_DECL
845 || TREE_CODE (x
) == VAR_DECL
846 || TREE_CODE (x
) == NAMESPACE_DECL
847 || TREE_CODE (x
) == CONST_DECL
848 || TREE_CODE (x
) == TEMPLATE_DECL
))
849 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
851 /* If new decl is `static' and an `extern' was seen previously,
853 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
854 warn_extern_redeclared_static (x
, t
);
858 /* Here to install a non-global value. */
859 tree oldlocal
= innermost_non_namespace_value (name
);
860 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
862 if (need_new_binding
)
864 push_local_binding (name
, x
, 0);
865 /* Because push_local_binding will hook X on to the
866 current_binding_level's name list, we don't want to
867 do that again below. */
868 need_new_binding
= 0;
871 /* If this is a TYPE_DECL, push it into the type value slot. */
872 if (TREE_CODE (x
) == TYPE_DECL
)
873 set_identifier_type_value (name
, x
);
875 /* Clear out any TYPE_DECL shadowed by a namespace so that
876 we won't think this is a type. The C struct hack doesn't
877 go through namespaces. */
878 if (TREE_CODE (x
) == NAMESPACE_DECL
)
879 set_identifier_type_value (name
, NULL_TREE
);
886 && TREE_CODE (oldlocal
) == VAR_DECL
887 && DECL_DEAD_FOR_LOCAL (oldlocal
))
888 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
890 if (oldlocal
== NULL_TREE
)
891 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
894 /* If this is an extern function declaration, see if we
895 have a global definition or declaration for the function. */
896 if (oldlocal
== NULL_TREE
898 && oldglobal
!= NULL_TREE
899 && TREE_CODE (x
) == FUNCTION_DECL
900 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
902 /* We have one. Their types must agree. */
903 if (decls_match (x
, oldglobal
))
907 warning (0, "extern declaration of %q#D doesn't match", x
);
908 warning (0, "global declaration %q+#D", oldglobal
);
911 /* If we have a local external declaration,
912 and no file-scope declaration has yet been seen,
913 then if we later have a file-scope decl it must not be static. */
914 if (oldlocal
== NULL_TREE
915 && oldglobal
== NULL_TREE
918 TREE_PUBLIC (name
) = 1;
920 /* Warn if shadowing an argument at the top level of the body. */
921 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
922 /* Inline decls shadow nothing. */
923 && !DECL_FROM_INLINE (x
)
924 && TREE_CODE (oldlocal
) == PARM_DECL
925 /* Don't check the `this' parameter. */
926 && !DECL_ARTIFICIAL (oldlocal
))
930 /* Don't complain if it's from an enclosing function. */
931 if (DECL_CONTEXT (oldlocal
) == current_function_decl
932 && TREE_CODE (x
) != PARM_DECL
)
934 /* Go to where the parms should be and see if we find
936 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
938 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
939 /* Skip the ctor/dtor cleanup level. */
943 if (b
->kind
== sk_function_parms
)
945 error ("declaration of %q#D shadows a parameter", x
);
950 if (warn_shadow
&& !err
)
952 warning (0, "declaration of %q#D shadows a parameter", x
);
953 warning (0, "%Jshadowed declaration is here", oldlocal
);
957 /* Maybe warn if shadowing something else. */
958 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
959 /* No shadow warnings for internally generated vars. */
960 && ! DECL_ARTIFICIAL (x
)
961 /* No shadow warnings for vars made for inlining. */
962 && ! DECL_FROM_INLINE (x
))
966 if (current_class_ptr
)
967 member
= lookup_member (current_class_type
,
970 /*want_type=*/false);
974 if (member
&& !TREE_STATIC (member
))
976 /* Location of previous decl is not useful in this case. */
977 warning (0, "declaration of %qD shadows a member of 'this'",
980 else if (oldlocal
!= NULL_TREE
981 && TREE_CODE (oldlocal
) == VAR_DECL
)
983 warning (0, "declaration of %qD shadows a previous local", x
);
984 warning (0, "%Jshadowed declaration is here", oldlocal
);
986 else if (oldglobal
!= NULL_TREE
987 && TREE_CODE (oldglobal
) == VAR_DECL
)
988 /* XXX shadow warnings in outer-more namespaces */
990 warning (0, "declaration of %qD shadows a global declaration",
992 warning (0, "%Jshadowed declaration is here", oldglobal
);
997 if (TREE_CODE (x
) == FUNCTION_DECL
)
998 check_default_args (x
);
1000 if (TREE_CODE (x
) == VAR_DECL
)
1001 maybe_register_incomplete_var (x
);
1004 if (need_new_binding
)
1005 add_decl_to_level (x
,
1006 DECL_NAMESPACE_SCOPE_P (x
)
1007 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1008 : current_binding_level
);
1010 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1013 /* Record a decl-node X as belonging to the current lexical scope. */
1018 return pushdecl_maybe_friend (x
, false);
1021 /* Enter DECL into the symbol table, if that's appropriate. Returns
1022 DECL, or a modified version thereof. */
1025 maybe_push_decl (tree decl
)
1027 tree type
= TREE_TYPE (decl
);
1029 /* Add this decl to the current binding level, but not if it comes
1030 from another scope, e.g. a static member variable. TEM may equal
1031 DECL or it may be a previous decl of the same name. */
1032 if (decl
== error_mark_node
1033 || (TREE_CODE (decl
) != PARM_DECL
1034 && DECL_CONTEXT (decl
) != NULL_TREE
1035 /* Definitions of namespace members outside their namespace are
1037 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
1038 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1039 || TREE_CODE (type
) == UNKNOWN_TYPE
1040 /* The declaration of a template specialization does not affect
1041 the functions available for overload resolution, so we do not
1043 || (TREE_CODE (decl
) == FUNCTION_DECL
1044 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1047 return pushdecl (decl
);
1050 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1051 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1052 doesn't really belong to this binding level, that it got here
1053 through a using-declaration. */
1056 push_local_binding (tree id
, tree decl
, int flags
)
1058 struct cp_binding_level
*b
;
1060 /* Skip over any local classes. This makes sense if we call
1061 push_local_binding with a friend decl of a local class. */
1062 b
= innermost_nonclass_level ();
1064 if (lookup_name_innermost_nonclass_level (id
))
1066 /* Supplement the existing binding. */
1067 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1068 /* It didn't work. Something else must be bound at this
1069 level. Do not add DECL to the list of things to pop
1074 /* Create a new binding. */
1075 push_binding (id
, decl
, b
);
1077 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1078 /* We must put the OVERLOAD into a TREE_LIST since the
1079 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1080 decls that got here through a using-declaration. */
1081 decl
= build_tree_list (NULL_TREE
, decl
);
1083 /* And put DECL on the list of things declared by the current
1085 add_decl_to_level (decl
, b
);
1088 /* Check to see whether or not DECL is a variable that would have been
1089 in scope under the ARM, but is not in scope under the ANSI/ISO
1090 standard. If so, issue an error message. If name lookup would
1091 work in both cases, but return a different result, this function
1092 returns the result of ANSI/ISO lookup. Otherwise, it returns
1096 check_for_out_of_scope_variable (tree decl
)
1100 /* We only care about out of scope variables. */
1101 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1104 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1105 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1106 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1107 && DECL_DEAD_FOR_LOCAL (shadowed
))
1108 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1109 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1111 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1114 if (!DECL_ERROR_REPORTED (decl
))
1116 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1117 warning (0, " matches this %q+D under ISO standard rules",
1119 warning (0, " matches this %q+D under old rules", decl
);
1120 DECL_ERROR_REPORTED (decl
) = 1;
1125 /* If we have already complained about this declaration, there's no
1126 need to do it again. */
1127 if (DECL_ERROR_REPORTED (decl
))
1130 DECL_ERROR_REPORTED (decl
) = 1;
1132 if (TREE_TYPE (decl
) == error_mark_node
)
1135 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1137 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1139 error (" cannot use obsolete binding at %q+D because "
1140 "it has a destructor", decl
);
1141 return error_mark_node
;
1145 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1147 pedwarn (" using obsolete binding at %q+D", decl
);
1153 /* true means unconditionally make a BLOCK for the next level pushed. */
1155 static bool keep_next_level_flag
;
1157 static int binding_depth
= 0;
1158 static int is_class_level
= 0;
1165 for (i
= 0; i
< depth
* 2; i
++)
1169 /* Return a string describing the kind of SCOPE we have. */
1171 cxx_scope_descriptor (cxx_scope
*scope
)
1173 /* The order of this table must match the "scope_kind"
1175 static const char* scope_kind_names
[] = {
1181 "function-parameter-scope",
1184 "template-parameter-scope",
1185 "template-explicit-spec-scope"
1187 const scope_kind kind
= scope
->explicit_spec_p
1188 ? sk_template_spec
: scope
->kind
;
1190 return scope_kind_names
[kind
];
1193 /* Output a debugging information about SCOPE when performing
1196 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1198 const char *desc
= cxx_scope_descriptor (scope
);
1199 if (scope
->this_entity
)
1200 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1201 scope
->this_entity
, (void *) scope
, line
);
1203 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1206 /* Return the estimated initial size of the hashtable of a NAMESPACE
1209 static inline size_t
1210 namespace_scope_ht_size (tree ns
)
1212 tree name
= DECL_NAME (ns
);
1214 return name
== std_identifier
1215 ? NAMESPACE_STD_HT_SIZE
1216 : (name
== global_scope_name
1217 ? GLOBAL_SCOPE_HT_SIZE
1218 : NAMESPACE_ORDINARY_HT_SIZE
);
1221 /* A chain of binding_level structures awaiting reuse. */
1223 static GTY((deletable
)) struct cp_binding_level
*free_binding_level
;
1225 /* Insert SCOPE as the innermost binding level. */
1228 push_binding_level (struct cp_binding_level
*scope
)
1230 /* Add it to the front of currently active scopes stack. */
1231 scope
->level_chain
= current_binding_level
;
1232 current_binding_level
= scope
;
1233 keep_next_level_flag
= false;
1235 if (ENABLE_SCOPE_CHECKING
)
1237 scope
->binding_depth
= binding_depth
;
1238 indent (binding_depth
);
1239 cxx_scope_debug (scope
, input_line
, "push");
1245 /* Create a new KIND scope and make it the top of the active scopes stack.
1246 ENTITY is the scope of the associated C++ entity (namespace, class,
1247 function); it is NULL otherwise. */
1250 begin_scope (scope_kind kind
, tree entity
)
1254 /* Reuse or create a struct for this binding level. */
1255 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1257 scope
= free_binding_level
;
1258 free_binding_level
= scope
->level_chain
;
1261 scope
= GGC_NEW (cxx_scope
);
1262 memset (scope
, 0, sizeof (cxx_scope
));
1264 scope
->this_entity
= entity
;
1265 scope
->more_cleanups_ok
= true;
1272 case sk_template_spec
:
1273 scope
->explicit_spec_p
= true;
1274 kind
= sk_template_parms
;
1276 case sk_template_parms
:
1282 case sk_function_parms
:
1283 scope
->keep
= keep_next_level_flag
;
1287 NAMESPACE_LEVEL (entity
) = scope
;
1288 scope
->static_decls
=
1289 VEC_alloc (tree
, gc
,
1290 DECL_NAME (entity
) == std_identifier
1291 || DECL_NAME (entity
) == global_scope_name
1296 /* Should not happen. */
1302 push_binding_level (scope
);
1307 /* We're about to leave current scope. Pop the top of the stack of
1308 currently active scopes. Return the enclosing scope, now active. */
1313 cxx_scope
*scope
= current_binding_level
;
1315 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1316 current_binding_level
= class_binding_level
;
1318 /* We cannot leave a scope, if there are none left. */
1319 if (NAMESPACE_LEVEL (global_namespace
))
1320 gcc_assert (!global_scope_p (scope
));
1322 if (ENABLE_SCOPE_CHECKING
)
1324 indent (--binding_depth
);
1325 cxx_scope_debug (scope
, input_line
, "leave");
1326 if (is_class_level
!= (scope
== class_binding_level
))
1328 indent (binding_depth
);
1329 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1334 /* Move one nesting level up. */
1335 current_binding_level
= scope
->level_chain
;
1337 /* Namespace-scopes are left most probably temporarily, not
1338 completely; they can be reopen later, e.g. in namespace-extension
1339 or any name binding activity that requires us to resume a
1340 namespace. For classes, we cache some binding levels. For other
1341 scopes, we just make the structure available for reuse. */
1342 if (scope
->kind
!= sk_namespace
1343 && scope
->kind
!= sk_class
)
1345 scope
->level_chain
= free_binding_level
;
1346 gcc_assert (!ENABLE_SCOPE_CHECKING
1347 || scope
->binding_depth
== binding_depth
);
1348 free_binding_level
= scope
;
1351 /* Find the innermost enclosing class scope, and reset
1352 CLASS_BINDING_LEVEL appropriately. */
1353 if (scope
->kind
== sk_class
)
1355 class_binding_level
= NULL
;
1356 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1357 if (scope
->kind
== sk_class
)
1359 class_binding_level
= scope
;
1364 return current_binding_level
;
1368 resume_scope (struct cp_binding_level
* b
)
1370 /* Resuming binding levels is meant only for namespaces,
1371 and those cannot nest into classes. */
1372 gcc_assert (!class_binding_level
);
1373 /* Also, resuming a non-directly nested namespace is a no-no. */
1374 gcc_assert (b
->level_chain
== current_binding_level
);
1375 current_binding_level
= b
;
1376 if (ENABLE_SCOPE_CHECKING
)
1378 b
->binding_depth
= binding_depth
;
1379 indent (binding_depth
);
1380 cxx_scope_debug (b
, input_line
, "resume");
1386 /* Return the innermost binding level that is not for a class scope. */
1389 innermost_nonclass_level (void)
1393 b
= current_binding_level
;
1394 while (b
->kind
== sk_class
)
1400 /* We're defining an object of type TYPE. If it needs a cleanup, but
1401 we're not allowed to add any more objects with cleanups to the current
1402 scope, create a new binding level. */
1405 maybe_push_cleanup_level (tree type
)
1407 if (type
!= error_mark_node
1408 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1409 && current_binding_level
->more_cleanups_ok
== 0)
1411 begin_scope (sk_cleanup
, NULL
);
1412 current_binding_level
->statement_list
= push_stmt_list ();
1416 /* Nonzero if we are currently in the global binding level. */
1419 global_bindings_p (void)
1421 return global_scope_p (current_binding_level
);
1424 /* True if we are currently in a toplevel binding level. This
1425 means either the global binding level or a namespace in a toplevel
1426 binding level. Since there are no non-toplevel namespace levels,
1427 this really means any namespace or template parameter level. We
1428 also include a class whose context is toplevel. */
1431 toplevel_bindings_p (void)
1433 struct cp_binding_level
*b
= innermost_nonclass_level ();
1435 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1438 /* True if this is a namespace scope, or if we are defining a class
1439 which is itself at namespace scope, or whose enclosing class is
1440 such a class, etc. */
1443 namespace_bindings_p (void)
1445 struct cp_binding_level
*b
= innermost_nonclass_level ();
1447 return b
->kind
== sk_namespace
;
1450 /* True if the current level needs to have a BLOCK made. */
1455 return (current_binding_level
->blocks
!= NULL_TREE
1456 || current_binding_level
->keep
1457 || current_binding_level
->kind
== sk_cleanup
1458 || current_binding_level
->names
!= NULL_TREE
);
1461 /* Returns the kind of the innermost scope. */
1464 innermost_scope_kind (void)
1466 return current_binding_level
->kind
;
1469 /* Returns true if this scope was created to store template parameters. */
1472 template_parm_scope_p (void)
1474 return innermost_scope_kind () == sk_template_parms
;
1477 /* If KEEP is true, make a BLOCK node for the next binding level,
1478 unconditionally. Otherwise, use the normal logic to decide whether
1479 or not to create a BLOCK. */
1482 keep_next_level (bool keep
)
1484 keep_next_level_flag
= keep
;
1487 /* Return the list of declarations of the current level.
1488 Note that this list is in reverse order unless/until
1489 you nreverse it; and when you do nreverse it, you must
1490 store the result back using `storedecls' or you will lose. */
1495 return current_binding_level
->names
;
1498 /* For debugging. */
1499 static int no_print_functions
= 0;
1500 static int no_print_builtins
= 0;
1503 print_binding_level (struct cp_binding_level
* lvl
)
1507 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1508 if (lvl
->more_cleanups_ok
)
1509 fprintf (stderr
, " more-cleanups-ok");
1510 if (lvl
->have_cleanups
)
1511 fprintf (stderr
, " have-cleanups");
1512 fprintf (stderr
, "\n");
1515 fprintf (stderr
, " names:\t");
1516 /* We can probably fit 3 names to a line? */
1517 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1519 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1521 if (no_print_builtins
1522 && (TREE_CODE (t
) == TYPE_DECL
)
1523 && DECL_IS_BUILTIN (t
))
1526 /* Function decls tend to have longer names. */
1527 if (TREE_CODE (t
) == FUNCTION_DECL
)
1534 fprintf (stderr
, "\n\t");
1537 print_node_brief (stderr
, "", t
, 0);
1538 if (t
== error_mark_node
)
1542 fprintf (stderr
, "\n");
1544 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1547 cp_class_binding
*b
;
1548 fprintf (stderr
, " class-shadowed:");
1550 VEC_iterate(cp_class_binding
, lvl
->class_shadowed
, i
, b
);
1552 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1553 fprintf (stderr
, "\n");
1555 if (lvl
->type_shadowed
)
1557 fprintf (stderr
, " type-shadowed:");
1558 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1560 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1562 fprintf (stderr
, "\n");
1567 print_other_binding_stack (struct cp_binding_level
*stack
)
1569 struct cp_binding_level
*level
;
1570 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1572 fprintf (stderr
, "binding level %p\n", (void *) level
);
1573 print_binding_level (level
);
1578 print_binding_stack (void)
1580 struct cp_binding_level
*b
;
1581 fprintf (stderr
, "current_binding_level=%p\n"
1582 "class_binding_level=%p\n"
1583 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1584 (void *) current_binding_level
, (void *) class_binding_level
,
1585 (void *) NAMESPACE_LEVEL (global_namespace
));
1586 if (class_binding_level
)
1588 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1589 if (b
== current_binding_level
)
1592 b
= class_binding_level
;
1594 b
= current_binding_level
;
1597 b
= current_binding_level
;
1598 print_other_binding_stack (b
);
1599 fprintf (stderr
, "global:\n");
1600 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1603 /* Return the type associated with id. */
1606 identifier_type_value (tree id
)
1608 timevar_push (TV_NAME_LOOKUP
);
1609 /* There is no type with that name, anywhere. */
1610 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1611 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1612 /* This is not the type marker, but the real thing. */
1613 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1614 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, REAL_IDENTIFIER_TYPE_VALUE (id
));
1615 /* Have to search for it. It must be on the global level, now.
1616 Ask lookup_name not to return non-types. */
1617 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1619 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, TREE_TYPE (id
));
1620 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1623 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1624 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1627 identifier_global_value (tree t
)
1629 return IDENTIFIER_GLOBAL_VALUE (t
);
1632 /* Push a definition of struct, union or enum tag named ID. into
1633 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1634 the tag ID is not already defined. */
1637 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1641 if (b
->kind
!= sk_namespace
)
1643 /* Shadow the marker, not the real thing, so that the marker
1644 gets restored later. */
1645 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1647 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1648 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1649 TREE_TYPE (b
->type_shadowed
) = type
;
1653 cxx_binding
*binding
=
1654 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1657 supplement_binding (binding
, decl
);
1659 binding
->value
= decl
;
1661 /* Store marker instead of real type. */
1662 type
= global_type_node
;
1664 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1667 /* As set_identifier_type_value_with_scope, but using
1668 current_binding_level. */
1671 set_identifier_type_value (tree id
, tree decl
)
1673 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1676 /* Return the name for the constructor (or destructor) for the
1677 specified class TYPE. When given a template, this routine doesn't
1678 lose the specialization. */
1681 constructor_name_full (tree type
)
1683 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1686 /* Return the name for the constructor (or destructor) for the
1687 specified class. When given a template, return the plain
1688 unspecialized name. */
1691 constructor_name (tree type
)
1694 name
= constructor_name_full (type
);
1695 if (IDENTIFIER_TEMPLATE (name
))
1696 name
= IDENTIFIER_TEMPLATE (name
);
1700 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1703 constructor_name_p (tree name
, tree type
)
1710 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1713 ctor_name
= constructor_name_full (type
);
1714 if (name
== ctor_name
)
1716 if (IDENTIFIER_TEMPLATE (ctor_name
)
1717 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1722 /* Counter used to create anonymous type names. */
1724 static GTY(()) int anon_cnt
;
1726 /* Return an IDENTIFIER which can be used as a name for
1727 anonymous structs and unions. */
1730 make_anon_name (void)
1734 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1735 return get_identifier (buf
);
1738 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1740 static inline cxx_binding
*
1741 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1743 timevar_push (TV_NAME_LOOKUP
);
1745 for (; binding
!= NULL
; binding
= binding
->previous
)
1746 if (binding
->scope
== scope
)
1747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
);
1749 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, (cxx_binding
*)0);
1752 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1754 static inline cxx_binding
*
1755 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1757 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1760 /* Fold-in case where NAME is used only once. */
1761 if (scope
== b
->scope
&& b
->previous
== NULL
)
1763 return find_binding (scope
, b
);
1768 /* Always returns a binding for name in scope. If no binding is
1769 found, make a new one. */
1771 static cxx_binding
*
1772 binding_for_name (cxx_scope
*scope
, tree name
)
1774 cxx_binding
*result
;
1776 result
= cxx_scope_find_binding_for_name (scope
, name
);
1779 /* Not found, make a new one. */
1780 result
= cxx_binding_make (NULL
, NULL
);
1781 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1782 result
->scope
= scope
;
1783 result
->is_local
= false;
1784 result
->value_is_inherited
= false;
1785 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1789 /* Insert another USING_DECL into the current binding level, returning
1790 this declaration. If this is a redeclaration, do nothing, and
1791 return NULL_TREE if this not in namespace scope (in namespace
1792 scope, a using decl might extend any previous bindings). */
1795 push_using_decl (tree scope
, tree name
)
1799 timevar_push (TV_NAME_LOOKUP
);
1800 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
1801 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1802 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
1803 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
1806 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
1807 namespace_bindings_p () ? decl
: NULL_TREE
);
1808 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
1809 USING_DECL_SCOPE (decl
) = scope
;
1810 TREE_CHAIN (decl
) = current_binding_level
->usings
;
1811 current_binding_level
->usings
= decl
;
1812 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1815 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1816 caller to set DECL_CONTEXT properly. */
1819 pushdecl_with_scope (tree x
, cxx_scope
*level
, bool is_friend
)
1821 struct cp_binding_level
*b
;
1822 tree function_decl
= current_function_decl
;
1824 timevar_push (TV_NAME_LOOKUP
);
1825 current_function_decl
= NULL_TREE
;
1826 if (level
->kind
== sk_class
)
1828 b
= class_binding_level
;
1829 class_binding_level
= level
;
1830 pushdecl_class_level (x
);
1831 class_binding_level
= b
;
1835 b
= current_binding_level
;
1836 current_binding_level
= level
;
1837 x
= pushdecl_maybe_friend (x
, is_friend
);
1838 current_binding_level
= b
;
1840 current_function_decl
= function_decl
;
1841 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1844 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1845 other definitions already in place. We get around this by making
1846 the value of the identifier point to a list of all the things that
1847 want to be referenced by that name. It is then up to the users of
1848 that name to decide what to do with that list.
1850 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1851 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1853 FLAGS is a bitwise-or of the following values:
1854 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1856 PUSH_USING: DECL is being pushed as the result of a using
1859 IS_FRIEND is true if this is a friend declaration.
1861 The value returned may be a previous declaration if we guessed wrong
1862 about what language DECL should belong to (C or C++). Otherwise,
1863 it's always DECL (and never something that's not a _DECL). */
1866 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
1868 tree name
= DECL_NAME (decl
);
1871 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
1873 timevar_push (TV_NAME_LOOKUP
);
1875 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
1877 old
= lookup_name_innermost_nonclass_level (name
);
1881 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
1883 tree t
= TREE_TYPE (old
);
1884 if (IS_AGGR_TYPE (t
) && warn_shadow
1885 && (! DECL_IN_SYSTEM_HEADER (decl
)
1886 || ! DECL_IN_SYSTEM_HEADER (old
)))
1887 warning (0, "%q#D hides constructor for %q#T", decl
, t
);
1890 else if (is_overloaded_fn (old
))
1894 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
1896 tree fn
= OVL_CURRENT (tmp
);
1898 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
1899 && !(flags
& PUSH_USING
)
1900 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1901 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
1902 && ! decls_match (fn
, decl
))
1903 error ("%q#D conflicts with previous using declaration %q#D",
1906 if (duplicate_decls (decl
, fn
, is_friend
) == fn
)
1907 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, fn
);
1910 /* We don't overload implicit built-ins. duplicate_decls()
1911 may fail to merge the decls if the new decl is e.g. a
1912 template function. */
1913 if (TREE_CODE (old
) == FUNCTION_DECL
1914 && DECL_ANTICIPATED (old
)
1915 && !DECL_HIDDEN_FRIEND_P (old
))
1918 else if (old
== error_mark_node
)
1919 /* Ignore the undefined symbol marker. */
1923 error ("previous non-function declaration %q+#D", old
);
1924 error ("conflicts with function declaration %q#D", decl
);
1925 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1929 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
1930 /* If it's a using declaration, we always need to build an OVERLOAD,
1931 because it's the only way to remember that the declaration comes
1932 from 'using', and have the lookup behave correctly. */
1933 || (flags
& PUSH_USING
))
1935 if (old
&& TREE_CODE (old
) != OVERLOAD
)
1936 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
1938 new_binding
= ovl_cons (decl
, old
);
1939 if (flags
& PUSH_USING
)
1940 OVL_USED (new_binding
) = 1;
1943 /* NAME is not ambiguous. */
1947 set_namespace_binding (name
, current_namespace
, new_binding
);
1950 /* We only create an OVERLOAD if there was a previous binding at
1951 this level, or if decl is a template. In the former case, we
1952 need to remove the old binding and replace it with the new
1953 binding. We must also run through the NAMES on the binding
1954 level where the name was bound to update the chain. */
1956 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
1960 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
1962 d
= &TREE_CHAIN (*d
))
1964 || (TREE_CODE (*d
) == TREE_LIST
1965 && TREE_VALUE (*d
) == old
))
1967 if (TREE_CODE (*d
) == TREE_LIST
)
1968 /* Just replace the old binding with the new. */
1969 TREE_VALUE (*d
) = new_binding
;
1971 /* Build a TREE_LIST to wrap the OVERLOAD. */
1972 *d
= tree_cons (NULL_TREE
, new_binding
,
1975 /* And update the cxx_binding node. */
1976 IDENTIFIER_BINDING (name
)->value
= new_binding
;
1977 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1980 /* We should always find a previous binding in this case. */
1984 /* Install the new binding. */
1985 push_local_binding (name
, new_binding
, flags
);
1988 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1991 /* Check a non-member using-declaration. Return the name and scope
1992 being used, and the USING_DECL, or NULL_TREE on failure. */
1995 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
1997 /* [namespace.udecl]
1998 A using-declaration for a class member shall be a
1999 member-declaration. */
2002 error ("%qT is not a namespace", scope
);
2005 else if (scope
== error_mark_node
)
2008 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2011 A using-declaration shall not name a template-id. */
2012 error ("a using-declaration cannot specify a template-id. "
2013 "Try %<using %D%>", name
);
2017 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2019 error ("namespace %qD not allowed in using-declaration", decl
);
2023 if (TREE_CODE (decl
) == SCOPE_REF
)
2025 /* It's a nested name with template parameter dependent scope.
2026 This can only be using-declaration for class member. */
2027 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2031 if (is_overloaded_fn (decl
))
2032 decl
= get_first_fn (decl
);
2034 gcc_assert (DECL_P (decl
));
2036 /* Make a USING_DECL. */
2037 return push_using_decl (scope
, name
);
2040 /* Process local and global using-declarations. */
2043 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2044 tree
*newval
, tree
*newtype
)
2046 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2048 *newval
= *newtype
= NULL_TREE
;
2049 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2053 if (!decls
.value
&& !decls
.type
)
2055 error ("%qD not declared", name
);
2059 /* It is impossible to overload a built-in function; any explicit
2060 declaration eliminates the built-in declaration. So, if OLDVAL
2061 is a built-in, then we can just pretend it isn't there. */
2063 && TREE_CODE (oldval
) == FUNCTION_DECL
2064 && DECL_ANTICIPATED (oldval
)
2065 && !DECL_HIDDEN_FRIEND_P (oldval
))
2068 /* Check for using functions. */
2069 if (decls
.value
&& is_overloaded_fn (decls
.value
))
2073 if (oldval
&& !is_overloaded_fn (oldval
))
2075 if (!DECL_IMPLICIT_TYPEDEF_P (oldval
))
2076 error ("%qD is already declared in this scope", name
);
2081 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2083 tree new_fn
= OVL_CURRENT (tmp
);
2085 /* [namespace.udecl]
2087 If a function declaration in namespace scope or block
2088 scope has the same name and the same parameter types as a
2089 function introduced by a using declaration the program is
2091 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2093 tree old_fn
= OVL_CURRENT (tmp1
);
2095 if (new_fn
== old_fn
)
2096 /* The function already exists in the current namespace. */
2098 else if (OVL_USED (tmp1
))
2099 continue; /* this is a using decl */
2100 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2101 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2103 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2104 || DECL_HIDDEN_FRIEND_P (old_fn
));
2106 /* There was already a non-using declaration in
2107 this scope with the same parameter types. If both
2108 are the same extern "C" functions, that's ok. */
2109 if (decls_match (new_fn
, old_fn
))
2113 error ("%qD is already declared in this scope", name
);
2119 /* If we broke out of the loop, there's no reason to add
2120 this function to the using declarations for this
2125 /* If we are adding to an existing OVERLOAD, then we no
2126 longer know the type of the set of functions. */
2127 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2128 TREE_TYPE (*newval
) = unknown_type_node
;
2129 /* Add this new function to the set. */
2130 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2131 /* If there is only one function, then we use its type. (A
2132 using-declaration naming a single function can be used in
2133 contexts where overload resolution cannot be
2135 if (TREE_CODE (*newval
) != OVERLOAD
)
2137 *newval
= ovl_cons (*newval
, NULL_TREE
);
2138 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2140 OVL_USED (*newval
) = 1;
2145 *newval
= decls
.value
;
2146 if (oldval
&& !decls_match (*newval
, oldval
))
2147 error ("%qD is already declared in this scope", name
);
2150 *newtype
= decls
.type
;
2151 if (oldtype
&& *newtype
&& !same_type_p (oldtype
, *newtype
))
2153 error ("using declaration %qD introduced ambiguous type %qT",
2159 /* Process a using-declaration at function scope. */
2162 do_local_using_decl (tree decl
, tree scope
, tree name
)
2164 tree oldval
, oldtype
, newval
, newtype
;
2165 tree orig_decl
= decl
;
2167 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2168 if (decl
== NULL_TREE
)
2171 if (building_stmt_tree ()
2172 && at_function_scope_p ())
2173 add_decl_expr (decl
);
2175 oldval
= lookup_name_innermost_nonclass_level (name
);
2176 oldtype
= lookup_type_current_level (name
);
2178 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2182 if (is_overloaded_fn (newval
))
2186 /* We only need to push declarations for those functions
2187 that were not already bound in the current level.
2188 The old value might be NULL_TREE, it might be a single
2189 function, or an OVERLOAD. */
2190 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2191 term
= OVL_FUNCTION (oldval
);
2194 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2196 push_overloaded_decl (OVL_CURRENT (fn
),
2197 PUSH_LOCAL
| PUSH_USING
,
2201 push_local_binding (name
, newval
, PUSH_USING
);
2205 push_local_binding (name
, newtype
, PUSH_USING
);
2206 set_identifier_type_value (name
, newtype
);
2209 /* Emit debug info. */
2210 if (!processing_template_decl
)
2211 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2214 /* Returns true if ROOT (a namespace, class, or function) encloses
2215 CHILD. CHILD may be either a class type or a namespace. */
2218 is_ancestor (tree root
, tree child
)
2220 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2221 || TREE_CODE (root
) == FUNCTION_DECL
2222 || CLASS_TYPE_P (root
)));
2223 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2224 || CLASS_TYPE_P (child
)));
2226 /* The global namespace encloses everything. */
2227 if (root
== global_namespace
)
2232 /* If we've run out of scopes, stop. */
2235 /* If we've reached the ROOT, it encloses CHILD. */
2238 /* Go out one level. */
2240 child
= TYPE_NAME (child
);
2241 child
= DECL_CONTEXT (child
);
2245 /* Enter the class or namespace scope indicated by T suitable for name
2246 lookup. T can be arbitrary scope, not necessary nested inside the
2247 current scope. Returns a non-null scope to pop iff pop_scope
2248 should be called later to exit this scope. */
2253 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2254 push_decl_namespace (t
);
2255 else if (CLASS_TYPE_P (t
))
2257 if (!at_class_scope_p ()
2258 || !same_type_p (current_class_type
, t
))
2259 push_nested_class (t
);
2261 /* T is the same as the current scope. There is therefore no
2262 need to re-enter the scope. Since we are not actually
2263 pushing a new scope, our caller should not call
2271 /* Leave scope pushed by push_scope. */
2276 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2277 pop_decl_namespace ();
2278 else if CLASS_TYPE_P (t
)
2279 pop_nested_class ();
2282 /* Subroutine of push_inner_scope. */
2285 push_inner_scope_r (tree outer
, tree inner
)
2290 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2293 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2295 push_inner_scope_r (outer
, prev
);
2296 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2298 struct cp_binding_level
*save_template_parm
= 0;
2299 /* Temporary take out template parameter scopes. They are saved
2300 in reversed order in save_template_parm. */
2301 while (current_binding_level
->kind
== sk_template_parms
)
2303 struct cp_binding_level
*b
= current_binding_level
;
2304 current_binding_level
= b
->level_chain
;
2305 b
->level_chain
= save_template_parm
;
2306 save_template_parm
= b
;
2309 resume_scope (NAMESPACE_LEVEL (inner
));
2310 current_namespace
= inner
;
2312 /* Restore template parameter scopes. */
2313 while (save_template_parm
)
2315 struct cp_binding_level
*b
= save_template_parm
;
2316 save_template_parm
= b
->level_chain
;
2317 b
->level_chain
= current_binding_level
;
2318 current_binding_level
= b
;
2325 /* Enter the scope INNER from current scope. INNER must be a scope
2326 nested inside current scope. This works with both name lookup and
2327 pushing name into scope. In case a template parameter scope is present,
2328 namespace is pushed under the template parameter scope according to
2329 name lookup rule in 14.6.1/6.
2331 Return the former current scope suitable for pop_inner_scope. */
2334 push_inner_scope (tree inner
)
2336 tree outer
= current_scope ();
2338 outer
= current_namespace
;
2340 push_inner_scope_r (outer
, inner
);
2344 /* Exit the current scope INNER back to scope OUTER. */
2347 pop_inner_scope (tree outer
, tree inner
)
2350 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2353 while (outer
!= inner
)
2355 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2357 struct cp_binding_level
*save_template_parm
= 0;
2358 /* Temporary take out template parameter scopes. They are saved
2359 in reversed order in save_template_parm. */
2360 while (current_binding_level
->kind
== sk_template_parms
)
2362 struct cp_binding_level
*b
= current_binding_level
;
2363 current_binding_level
= b
->level_chain
;
2364 b
->level_chain
= save_template_parm
;
2365 save_template_parm
= b
;
2370 /* Restore template parameter scopes. */
2371 while (save_template_parm
)
2373 struct cp_binding_level
*b
= save_template_parm
;
2374 save_template_parm
= b
->level_chain
;
2375 b
->level_chain
= current_binding_level
;
2376 current_binding_level
= b
;
2382 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2386 /* Do a pushlevel for class declarations. */
2389 pushlevel_class (void)
2391 if (ENABLE_SCOPE_CHECKING
)
2394 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2397 /* ...and a poplevel for class declarations. */
2400 poplevel_class (void)
2402 struct cp_binding_level
*level
= class_binding_level
;
2403 cp_class_binding
*cb
;
2407 timevar_push (TV_NAME_LOOKUP
);
2408 gcc_assert (level
!= 0);
2410 /* If we're leaving a toplevel class, cache its binding level. */
2411 if (current_class_depth
== 1)
2412 previous_class_level
= level
;
2413 for (shadowed
= level
->type_shadowed
;
2415 shadowed
= TREE_CHAIN (shadowed
))
2416 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2418 /* Remove the bindings for all of the class-level declarations. */
2419 if (level
->class_shadowed
)
2422 VEC_iterate (cp_class_binding
, level
->class_shadowed
, i
, cb
);
2424 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
.previous
;
2425 ggc_free (level
->class_shadowed
);
2426 level
->class_shadowed
= NULL
;
2429 /* Now, pop out of the binding level which we created up in the
2430 `pushlevel_class' routine. */
2431 if (ENABLE_SCOPE_CHECKING
)
2435 timevar_pop (TV_NAME_LOOKUP
);
2438 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2439 appropriate. DECL is the value to which a name has just been
2440 bound. CLASS_TYPE is the class in which the lookup occurred. */
2443 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2446 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2450 if (TREE_CODE (decl
) == OVERLOAD
)
2451 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2454 gcc_assert (DECL_P (decl
));
2455 context
= context_for_name_lookup (decl
);
2458 if (is_properly_derived_from (class_type
, context
))
2459 INHERITED_VALUE_BINDING_P (binding
) = 1;
2461 INHERITED_VALUE_BINDING_P (binding
) = 0;
2463 else if (binding
->value
== decl
)
2464 /* We only encounter a TREE_LIST when there is an ambiguity in the
2465 base classes. Such an ambiguity can be overridden by a
2466 definition in this class. */
2467 INHERITED_VALUE_BINDING_P (binding
) = 1;
2469 INHERITED_VALUE_BINDING_P (binding
) = 0;
2472 /* Make the declaration of X appear in CLASS scope. */
2475 pushdecl_class_level (tree x
)
2478 bool is_valid
= true;
2480 timevar_push (TV_NAME_LOOKUP
);
2481 /* Get the name of X. */
2482 if (TREE_CODE (x
) == OVERLOAD
)
2483 name
= DECL_NAME (get_first_fn (x
));
2485 name
= DECL_NAME (x
);
2489 is_valid
= push_class_level_binding (name
, x
);
2490 if (TREE_CODE (x
) == TYPE_DECL
)
2491 set_identifier_type_value (name
, x
);
2493 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2495 /* If X is an anonymous aggregate, all of its members are
2496 treated as if they were members of the class containing the
2497 aggregate, for naming purposes. */
2500 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= TREE_CHAIN (f
))
2502 location_t save_location
= input_location
;
2503 input_location
= DECL_SOURCE_LOCATION (f
);
2504 if (!pushdecl_class_level (f
))
2506 input_location
= save_location
;
2509 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, is_valid
);
2512 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2513 scope. If the value returned is non-NULL, and the PREVIOUS field
2514 is not set, callers must set the PREVIOUS field explicitly. */
2516 static cxx_binding
*
2517 get_class_binding (tree name
, cxx_scope
*scope
)
2522 cxx_binding
*binding
;
2524 class_type
= scope
->this_entity
;
2526 /* Get the type binding. */
2527 type_binding
= lookup_member (class_type
, name
,
2528 /*protect=*/2, /*want_type=*/true);
2529 /* Get the value binding. */
2530 value_binding
= lookup_member (class_type
, name
,
2531 /*protect=*/2, /*want_type=*/false);
2534 && (TREE_CODE (value_binding
) == TYPE_DECL
2535 || DECL_CLASS_TEMPLATE_P (value_binding
)
2536 || (TREE_CODE (value_binding
) == TREE_LIST
2537 && TREE_TYPE (value_binding
) == error_mark_node
2538 && (TREE_CODE (TREE_VALUE (value_binding
))
2540 /* We found a type binding, even when looking for a non-type
2541 binding. This means that we already processed this binding
2544 else if (value_binding
)
2546 if (TREE_CODE (value_binding
) == TREE_LIST
2547 && TREE_TYPE (value_binding
) == error_mark_node
)
2548 /* NAME is ambiguous. */
2550 else if (BASELINK_P (value_binding
))
2551 /* NAME is some overloaded functions. */
2552 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2555 /* If we found either a type binding or a value binding, create a
2556 new binding object. */
2557 if (type_binding
|| value_binding
)
2559 binding
= new_class_binding (name
,
2563 /* This is a class-scope binding, not a block-scope binding. */
2564 LOCAL_BINDING_P (binding
) = 0;
2565 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2573 /* Make the declaration(s) of X appear in CLASS scope under the name
2574 NAME. Returns true if the binding is valid. */
2577 push_class_level_binding (tree name
, tree x
)
2579 cxx_binding
*binding
;
2583 timevar_push (TV_NAME_LOOKUP
);
2584 /* The class_binding_level will be NULL if x is a template
2585 parameter name in a member template. */
2586 if (!class_binding_level
)
2587 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2589 /* Check for invalid member names. */
2590 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2591 /* We could have been passed a tree list if this is an ambiguous
2592 declaration. If so, pull the declaration out because
2593 check_template_shadow will not handle a TREE_LIST. */
2594 if (TREE_CODE (decl
) == TREE_LIST
2595 && TREE_TYPE (decl
) == error_mark_node
)
2596 decl
= TREE_VALUE (decl
);
2598 check_template_shadow (decl
);
2602 If T is the name of a class, then each of the following shall
2603 have a name different from T:
2605 -- every static data member of class T;
2607 -- every member of class T that is itself a type;
2609 -- every enumerator of every member of class T that is an
2612 -- every member of every anonymous union that is a member of
2615 (Non-static data members were also forbidden to have the same
2616 name as T until TC1.) */
2617 if ((TREE_CODE (x
) == VAR_DECL
2618 || TREE_CODE (x
) == CONST_DECL
2619 || (TREE_CODE (x
) == TYPE_DECL
2620 && !DECL_SELF_REFERENCE_P (x
))
2621 /* A data member of an anonymous union. */
2622 || (TREE_CODE (x
) == FIELD_DECL
2623 && DECL_CONTEXT (x
) != current_class_type
))
2624 && DECL_NAME (x
) == constructor_name (current_class_type
))
2626 tree scope
= context_for_name_lookup (x
);
2627 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
2629 error ("%qD has the same name as the class in which it is "
2632 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2636 /* Get the current binding for NAME in this class, if any. */
2637 binding
= IDENTIFIER_BINDING (name
);
2638 if (!binding
|| binding
->scope
!= class_binding_level
)
2640 binding
= get_class_binding (name
, class_binding_level
);
2641 /* If a new binding was created, put it at the front of the
2642 IDENTIFIER_BINDING list. */
2645 binding
->previous
= IDENTIFIER_BINDING (name
);
2646 IDENTIFIER_BINDING (name
) = binding
;
2650 /* If there is already a binding, then we may need to update the
2652 if (binding
&& binding
->value
)
2654 tree bval
= binding
->value
;
2655 tree old_decl
= NULL_TREE
;
2657 if (INHERITED_VALUE_BINDING_P (binding
))
2659 /* If the old binding was from a base class, and was for a
2660 tag name, slide it over to make room for the new binding.
2661 The old binding is still visible if explicitly qualified
2662 with a class-key. */
2663 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2664 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2666 old_decl
= binding
->type
;
2667 binding
->type
= bval
;
2668 binding
->value
= NULL_TREE
;
2669 INHERITED_VALUE_BINDING_P (binding
) = 0;
2674 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2676 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2677 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2678 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
2680 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
2681 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2683 if (old_decl
&& binding
->scope
== class_binding_level
)
2686 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2687 here. This function is only used to register bindings
2688 from with the class definition itself. */
2689 INHERITED_VALUE_BINDING_P (binding
) = 0;
2690 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2694 /* Note that we declared this value so that we can issue an error if
2695 this is an invalid redeclaration of a name already used for some
2697 note_name_declared_in_class (name
, decl
);
2699 /* If we didn't replace an existing binding, put the binding on the
2700 stack of bindings for the identifier, and update the shadowed
2702 if (binding
&& binding
->scope
== class_binding_level
)
2703 /* Supplement the existing binding. */
2704 ok
= supplement_binding (binding
, decl
);
2707 /* Create a new binding. */
2708 push_binding (name
, decl
, class_binding_level
);
2712 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
2715 /* Process "using SCOPE::NAME" in a class scope. Return the
2716 USING_DECL created. */
2719 do_class_using_decl (tree scope
, tree name
)
2721 tree value
, decl
, binfo
;
2725 if (!scope
|| !TYPE_P (scope
))
2727 error ("using-declaration for non-member at class scope");
2731 /* Make sure the scope is a base. */
2732 dependent_p
= dependent_type_p (scope
);
2734 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
2738 if (same_type_p (current_class_type
, scope
))
2739 b_kind
= bk_same_type
;
2741 b_kind
= bk_proper_base
;
2744 if (b_kind
< bk_proper_base
)
2746 error_not_base_type (scope
, current_class_type
);
2750 /* Make sure the name is not invalid */
2751 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2753 error ("%<%T::%D%> names destructor", scope
, name
);
2756 if (constructor_name_p (name
, scope
))
2758 error ("%<%T::%D%> names constructor", scope
, name
);
2761 if (constructor_name_p (name
, current_class_type
))
2763 error ("%<%T::%D%> names constructor in %qT",
2764 scope
, name
, current_class_type
);
2769 && IDENTIFIER_OPNAME_P (name
) && dependent_type_p (TREE_TYPE (name
)))
2772 /* See if there are any members of the base. */
2775 decl
= lookup_member (binfo
, name
, 0, false);
2779 error ("no members matching %<%T::%D%> in %q#T", scope
, name
, scope
);
2783 if (BASELINK_P (decl
))
2784 /* Ignore base type this came from. */
2785 decl
= BASELINK_FUNCTIONS (decl
);
2790 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2791 USING_DECL_DECLS (value
) = decl
;
2792 USING_DECL_SCOPE (value
) = scope
;
2793 DECL_DEPENDENT_P (value
) = dependent_p
;
2799 /* Return the binding value for name in scope. */
2802 namespace_binding (tree name
, tree scope
)
2804 cxx_binding
*binding
;
2807 scope
= global_namespace
;
2809 /* Unnecessary for the global namespace because it can't be an alias. */
2810 scope
= ORIGINAL_NAMESPACE (scope
);
2812 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2814 return binding
? binding
->value
: NULL_TREE
;
2817 /* Set the binding value for name in scope. */
2820 set_namespace_binding (tree name
, tree scope
, tree val
)
2824 timevar_push (TV_NAME_LOOKUP
);
2825 if (scope
== NULL_TREE
)
2826 scope
= global_namespace
;
2827 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2828 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
2831 supplement_binding (b
, val
);
2832 timevar_pop (TV_NAME_LOOKUP
);
2835 /* Set the context of a declaration to scope. Complain if we are not
2839 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
2843 /* Get rid of namespace aliases. */
2844 scope
= ORIGINAL_NAMESPACE (scope
);
2846 /* It is ok for friends to be qualified in parallel space. */
2847 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
2848 error ("declaration of %qD not in a namespace surrounding %qD",
2850 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
2852 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2853 if (scope
== current_namespace
)
2855 if (at_namespace_scope_p ())
2856 error ("explicit qualification in declaration of %qD",
2861 /* See whether this has been declared in the namespace. */
2862 old
= namespace_binding (DECL_NAME (decl
), scope
);
2864 /* No old declaration at all. */
2866 /* A template can be explicitly specialized in any namespace. */
2867 if (processing_explicit_instantiation
)
2869 if (!is_overloaded_fn (decl
))
2870 /* Don't compare non-function decls with decls_match here, since
2871 it can't check for the correct constness at this
2872 point. pushdecl will find those errors later. */
2874 /* Since decl is a function, old should contain a function decl. */
2875 if (!is_overloaded_fn (old
))
2877 if (processing_template_decl
|| processing_specialization
)
2878 /* We have not yet called push_template_decl to turn a
2879 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2880 match. But, we'll check later, when we construct the
2883 /* Instantiations or specializations of templates may be declared as
2884 friends in any namespace. */
2885 if (friendp
&& DECL_USE_TEMPLATE (decl
))
2887 if (is_overloaded_fn (old
))
2889 for (; old
; old
= OVL_NEXT (old
))
2890 if (decls_match (decl
, OVL_CURRENT (old
)))
2893 else if (decls_match (decl
, old
))
2896 error ("%qD should have been declared inside %qD", decl
, scope
);
2899 /* Return the namespace where the current declaration is declared. */
2902 current_decl_namespace (void)
2905 /* If we have been pushed into a different namespace, use it. */
2906 if (decl_namespace_list
)
2907 return TREE_PURPOSE (decl_namespace_list
);
2909 if (current_class_type
)
2910 result
= decl_namespace_context (current_class_type
);
2911 else if (current_function_decl
)
2912 result
= decl_namespace_context (current_function_decl
);
2914 result
= current_namespace
;
2918 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2919 select a name that is unique to this compilation unit. */
2922 push_namespace (tree name
)
2926 int implicit_use
= 0;
2929 timevar_push (TV_NAME_LOOKUP
);
2931 /* We should not get here if the global_namespace is not yet constructed
2932 nor if NAME designates the global namespace: The global scope is
2933 constructed elsewhere. */
2934 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
2938 /* The name of anonymous namespace is unique for the translation
2940 if (!anonymous_namespace_name
)
2941 anonymous_namespace_name
= get_file_function_name ('N');
2942 name
= anonymous_namespace_name
;
2943 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2945 /* Reopening anonymous namespace. */
2951 /* Check whether this is an extended namespace definition. */
2952 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2953 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2956 if (DECL_NAMESPACE_ALIAS (d
))
2958 error ("namespace alias %qD not allowed here, assuming %qD",
2959 d
, DECL_NAMESPACE_ALIAS (d
));
2960 d
= DECL_NAMESPACE_ALIAS (d
);
2967 /* Make a new namespace, binding the name to it. */
2968 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2969 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
2973 /* Clear DECL_NAME for the benefit of debugging back ends. */
2974 SET_DECL_ASSEMBLER_NAME (d
, name
);
2975 DECL_NAME (d
) = NULL_TREE
;
2977 begin_scope (sk_namespace
, d
);
2980 resume_scope (NAMESPACE_LEVEL (d
));
2983 do_using_directive (d
);
2984 /* Enter the name space. */
2985 current_namespace
= d
;
2987 timevar_pop (TV_NAME_LOOKUP
);
2990 /* Pop from the scope of the current namespace. */
2993 pop_namespace (void)
2995 gcc_assert (current_namespace
!= global_namespace
);
2996 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2997 /* The binding level is not popped, as it might be re-opened later. */
3001 /* Push into the scope of the namespace NS, even if it is deeply
3002 nested within another namespace. */
3005 push_nested_namespace (tree ns
)
3007 if (ns
== global_namespace
)
3008 push_to_top_level ();
3011 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3012 push_namespace (DECL_NAME (ns
));
3016 /* Pop back from the scope of the namespace NS, which was previously
3017 entered with push_nested_namespace. */
3020 pop_nested_namespace (tree ns
)
3022 timevar_push (TV_NAME_LOOKUP
);
3023 while (ns
!= global_namespace
)
3026 ns
= CP_DECL_CONTEXT (ns
);
3029 pop_from_top_level ();
3030 timevar_pop (TV_NAME_LOOKUP
);
3033 /* Temporarily set the namespace for the current declaration. */
3036 push_decl_namespace (tree decl
)
3038 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3039 decl
= decl_namespace_context (decl
);
3040 decl_namespace_list
= tree_cons (ORIGINAL_NAMESPACE (decl
),
3041 NULL_TREE
, decl_namespace_list
);
3044 /* [namespace.memdef]/2 */
3047 pop_decl_namespace (void)
3049 decl_namespace_list
= TREE_CHAIN (decl_namespace_list
);
3052 /* Return the namespace that is the common ancestor
3053 of two given namespaces. */
3056 namespace_ancestor (tree ns1
, tree ns2
)
3058 timevar_push (TV_NAME_LOOKUP
);
3059 if (is_ancestor (ns1
, ns2
))
3060 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ns1
);
3061 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
3062 namespace_ancestor (CP_DECL_CONTEXT (ns1
), ns2
));
3065 /* Process a namespace-alias declaration. */
3068 do_namespace_alias (tree alias
, tree
namespace)
3070 if (namespace == error_mark_node
)
3073 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL
);
3075 namespace = ORIGINAL_NAMESPACE (namespace);
3077 /* Build the alias. */
3078 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3079 DECL_NAMESPACE_ALIAS (alias
) = namespace;
3080 DECL_EXTERNAL (alias
) = 1;
3081 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3084 /* Emit debug info for namespace alias. */
3085 (*debug_hooks
->global_decl
) (alias
);
3088 /* Like pushdecl, only it places X in the current namespace,
3092 pushdecl_namespace_level (tree x
, bool is_friend
)
3094 struct cp_binding_level
*b
= current_binding_level
;
3097 timevar_push (TV_NAME_LOOKUP
);
3098 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3100 /* Now, the type_shadowed stack may screw us. Munge it so it does
3102 if (TREE_CODE (t
) == TYPE_DECL
)
3104 tree name
= DECL_NAME (t
);
3106 tree
*ptr
= (tree
*)0;
3107 for (; !global_scope_p (b
); b
= b
->level_chain
)
3109 tree shadowed
= b
->type_shadowed
;
3110 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3111 if (TREE_PURPOSE (shadowed
) == name
)
3113 ptr
= &TREE_VALUE (shadowed
);
3114 /* Can't break out of the loop here because sometimes
3115 a binding level will have duplicate bindings for
3116 PT names. It's gross, but I haven't time to fix it. */
3119 newval
= TREE_TYPE (t
);
3120 if (ptr
== (tree
*)0)
3122 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3123 up here if this is changed to an assertion. --KR */
3124 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3131 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3134 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3135 directive is not directly from the source. Also find the common
3136 ancestor and let our users know about the new namespace */
3138 add_using_namespace (tree user
, tree used
, bool indirect
)
3141 timevar_push (TV_NAME_LOOKUP
);
3142 /* Using oneself is a no-op. */
3145 timevar_pop (TV_NAME_LOOKUP
);
3148 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3149 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3150 /* Check if we already have this. */
3151 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3155 /* Promote to direct usage. */
3156 TREE_INDIRECT_USING (t
) = 0;
3157 timevar_pop (TV_NAME_LOOKUP
);
3161 /* Add used to the user's using list. */
3162 DECL_NAMESPACE_USING (user
)
3163 = tree_cons (used
, namespace_ancestor (user
, used
),
3164 DECL_NAMESPACE_USING (user
));
3166 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3168 /* Add user to the used's users list. */
3169 DECL_NAMESPACE_USERS (used
)
3170 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3172 /* Recursively add all namespaces used. */
3173 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3174 /* indirect usage */
3175 add_using_namespace (user
, TREE_PURPOSE (t
), 1);
3177 /* Tell everyone using us about the new used namespaces. */
3178 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3179 add_using_namespace (TREE_PURPOSE (t
), used
, 1);
3180 timevar_pop (TV_NAME_LOOKUP
);
3183 /* Process a using-declaration not appearing in class or local scope. */
3186 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3188 tree oldval
, oldtype
, newval
, newtype
;
3189 tree orig_decl
= decl
;
3190 cxx_binding
*binding
;
3192 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3193 if (decl
== NULL_TREE
)
3196 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3198 oldval
= binding
->value
;
3199 oldtype
= binding
->type
;
3201 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3203 /* Emit debug info. */
3204 if (!processing_template_decl
)
3205 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3207 /* Copy declarations found. */
3209 binding
->value
= newval
;
3211 binding
->type
= newtype
;
3215 /* Process a using-directive. */
3218 do_using_directive (tree
namespace)
3220 tree context
= NULL_TREE
;
3222 if (namespace == error_mark_node
)
3225 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL
);
3227 if (building_stmt_tree ())
3228 add_stmt (build_stmt (USING_STMT
, namespace));
3229 namespace = ORIGINAL_NAMESPACE (namespace);
3231 if (!toplevel_bindings_p ())
3233 push_using_directive (namespace);
3234 context
= current_scope ();
3239 add_using_namespace (current_namespace
, namespace, 0);
3240 if (current_namespace
!= global_namespace
)
3241 context
= current_namespace
;
3244 /* Emit debugging info. */
3245 if (!processing_template_decl
)
3246 (*debug_hooks
->imported_module_or_decl
) (namespace, context
);
3249 /* Deal with a using-directive seen by the parser. Currently we only
3250 handle attributes here, since they cannot appear inside a template. */
3253 parse_using_directive (tree
namespace, tree attribs
)
3257 do_using_directive (namespace);
3259 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3261 tree name
= TREE_PURPOSE (a
);
3262 if (is_attribute_p ("strong", name
))
3264 if (!toplevel_bindings_p ())
3265 error ("strong using only meaningful at namespace scope");
3266 else if (namespace != error_mark_node
)
3267 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3268 = tree_cons (current_namespace
, 0,
3269 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3272 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3276 /* Like pushdecl, only it places X in the global scope if appropriate.
3277 Calls cp_finish_decl to register the variable, initializing it with
3278 *INIT, if INIT is non-NULL. */
3281 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3283 timevar_push (TV_NAME_LOOKUP
);
3284 push_to_top_level ();
3285 x
= pushdecl_namespace_level (x
, is_friend
);
3287 cp_finish_decl (x
, *init
, NULL_TREE
, 0);
3288 pop_from_top_level ();
3289 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
3292 /* Like pushdecl, only it places X in the global scope if appropriate. */
3295 pushdecl_top_level (tree x
)
3297 return pushdecl_top_level_1 (x
, NULL
, false);
3300 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3303 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3305 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3308 /* Like pushdecl, only it places X in the global scope if
3309 appropriate. Calls cp_finish_decl to register the variable,
3310 initializing it with INIT. */
3313 pushdecl_top_level_and_finish (tree x
, tree init
)
3315 return pushdecl_top_level_1 (x
, &init
, false);
3318 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3319 duplicates. The first list becomes the tail of the result.
3321 The algorithm is O(n^2). We could get this down to O(n log n) by
3322 doing a sort on the addresses of the functions, if that becomes
3326 merge_functions (tree s1
, tree s2
)
3328 for (; s2
; s2
= OVL_NEXT (s2
))
3330 tree fn2
= OVL_CURRENT (s2
);
3333 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3335 tree fn1
= OVL_CURRENT (fns1
);
3337 /* If the function from S2 is already in S1, there is no
3338 need to add it again. For `extern "C"' functions, we
3339 might have two FUNCTION_DECLs for the same function, in
3340 different namespaces; again, we only need one of them. */
3342 || (DECL_EXTERN_C_P (fn1
) && DECL_EXTERN_C_P (fn2
)
3343 && DECL_NAME (fn1
) == DECL_NAME (fn2
)))
3347 /* If we exhausted all of the functions in S1, FN2 is new. */
3349 s1
= build_overload (fn2
, s1
);
3354 /* This should return an error not all definitions define functions.
3355 It is not an error if we find two functions with exactly the
3356 same signature, only if these are selected in overload resolution.
3357 old is the current set of bindings, new the freshly-found binding.
3358 XXX Do we want to give *all* candidates in case of ambiguity?
3359 XXX In what way should I treat extern declarations?
3360 XXX I don't want to repeat the entire duplicate_decls here */
3363 ambiguous_decl (tree name
, struct scope_binding
*old
, cxx_binding
*new,
3367 gcc_assert (old
!= NULL
);
3368 /* Copy the value. */
3371 switch (TREE_CODE (val
))
3374 /* If we expect types or namespaces, and not templates,
3375 or this is not a template class. */
3376 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3377 && !DECL_CLASS_TEMPLATE_P (val
))
3378 || hidden_name_p (val
))
3382 if (LOOKUP_NAMESPACES_ONLY (flags
) || hidden_name_p (val
))
3385 case NAMESPACE_DECL
:
3386 if (LOOKUP_TYPES_ONLY (flags
))
3390 /* Ignore built-in functions that are still anticipated. */
3391 if (LOOKUP_QUALIFIERS_ONLY (flags
) || hidden_name_p (val
))
3395 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3401 else if (val
&& val
!= old
->value
)
3403 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3404 old
->value
= merge_functions (old
->value
, val
);
3407 old
->value
= tree_cons (NULL_TREE
, old
->value
,
3408 build_tree_list (NULL_TREE
, new->value
));
3409 TREE_TYPE (old
->value
) = error_mark_node
;
3412 /* ... and copy the type. */
3414 if (LOOKUP_NAMESPACES_ONLY (flags
))
3418 else if (type
&& old
->type
!= type
)
3420 if (flags
& LOOKUP_COMPLAIN
)
3422 error ("%qD denotes an ambiguous type",name
);
3423 error ("%J first type here", TYPE_MAIN_DECL (old
->type
));
3424 error ("%J other type here", TYPE_MAIN_DECL (type
));
3429 /* Return the declarations that are members of the namespace NS. */
3432 cp_namespace_decls (tree ns
)
3434 return NAMESPACE_LEVEL (ns
)->names
;
3437 /* Combine prefer_type and namespaces_only into flags. */
3440 lookup_flags (int prefer_type
, int namespaces_only
)
3442 if (namespaces_only
)
3443 return LOOKUP_PREFER_NAMESPACES
;
3444 if (prefer_type
> 1)
3445 return LOOKUP_PREFER_TYPES
;
3446 if (prefer_type
> 0)
3447 return LOOKUP_PREFER_BOTH
;
3451 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3452 ignore it or not. Subroutine of lookup_name_real and
3453 lookup_type_scope. */
3456 qualify_lookup (tree val
, int flags
)
3458 if (val
== NULL_TREE
)
3460 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3462 if ((flags
& LOOKUP_PREFER_TYPES
)
3463 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3465 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
3470 /* Given a lookup that returned VAL, decide if we want to ignore it or
3471 not based on DECL_ANTICIPATED. */
3474 hidden_name_p (tree val
)
3477 && DECL_LANG_SPECIFIC (val
)
3478 && DECL_ANTICIPATED (val
))
3483 /* Remove any hidden friend functions from a possibly overloaded set
3487 remove_hidden_names (tree fns
)
3492 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
3494 else if (TREE_CODE (fns
) == OVERLOAD
)
3498 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3499 if (hidden_name_p (OVL_CURRENT (o
)))
3505 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3506 if (!hidden_name_p (OVL_CURRENT (o
)))
3507 n
= build_overload (OVL_CURRENT (o
), n
);
3515 /* Look up NAME in the NAMESPACE. */
3518 lookup_namespace_name (tree
namespace, tree name
)
3521 tree template_id
= NULL_TREE
;
3522 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3524 timevar_push (TV_NAME_LOOKUP
);
3525 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL
);
3527 if (TREE_CODE (name
) == NAMESPACE_DECL
)
3528 /* This happens for A::B<int> when B is a namespace. */
3529 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, name
);
3530 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
3532 /* This happens for A::B where B is a template, and there are no
3533 template arguments. */
3534 error ("invalid use of %qD", name
);
3535 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3538 namespace = ORIGINAL_NAMESPACE (namespace);
3540 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3543 name
= TREE_OPERAND (name
, 0);
3544 if (TREE_CODE (name
) == OVERLOAD
)
3545 name
= DECL_NAME (OVL_CURRENT (name
));
3546 else if (DECL_P (name
))
3547 name
= DECL_NAME (name
);
3550 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
3552 if (!qualified_lookup_using_namespace (name
, namespace, &binding
, 0))
3553 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3557 val
= binding
.value
;
3561 if (DECL_CLASS_TEMPLATE_P (val
))
3562 val
= lookup_template_class (val
,
3563 TREE_OPERAND (template_id
, 1),
3564 /*in_decl=*/NULL_TREE
,
3565 /*context=*/NULL_TREE
,
3566 /*entering_scope=*/0,
3567 tf_error
| tf_warning
);
3568 else if (DECL_FUNCTION_TEMPLATE_P (val
)
3569 || TREE_CODE (val
) == OVERLOAD
)
3570 val
= lookup_template_function (val
,
3571 TREE_OPERAND (template_id
, 1));
3574 error ("%<%D::%D%> is not a template", namespace, name
);
3575 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3579 /* If we have a single function from a using decl, pull it out. */
3580 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
3581 val
= OVL_FUNCTION (val
);
3583 /* Ignore built-in functions and friends that haven't been declared
3585 if (!val
|| !hidden_name_p (val
))
3586 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3589 error ("%qD undeclared in namespace %qD", name
, namespace);
3590 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3593 /* Select the right _DECL from multiple choices. */
3596 select_decl (const struct scope_binding
*binding
, int flags
)
3599 val
= binding
->value
;
3601 timevar_push (TV_NAME_LOOKUP
);
3602 if (LOOKUP_NAMESPACES_ONLY (flags
))
3604 /* We are not interested in types. */
3605 if (val
&& (TREE_CODE (val
) == NAMESPACE_DECL
3606 || TREE_CODE (val
) == TREE_LIST
))
3607 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3608 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3611 /* If looking for a type, or if there is no non-type binding, select
3612 the value binding. */
3613 if (binding
->type
&& (!val
|| (flags
& LOOKUP_PREFER_TYPES
)))
3614 val
= binding
->type
;
3615 /* Don't return non-types if we really prefer types. */
3616 else if (val
&& LOOKUP_TYPES_ONLY (flags
)
3617 && ! DECL_DECLARES_TYPE_P (val
))
3620 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3623 /* Unscoped lookup of a global: iterate over current namespaces,
3624 considering using-directives. */
3627 unqualified_namespace_lookup (tree name
, int flags
)
3629 tree initial
= current_decl_namespace ();
3630 tree scope
= initial
;
3632 struct cp_binding_level
*level
;
3633 tree val
= NULL_TREE
;
3634 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3636 timevar_push (TV_NAME_LOOKUP
);
3638 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
3641 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3645 if (b
->value
&& hidden_name_p (b
->value
))
3646 /* Ignore anticipated built-in functions and friends. */
3649 binding
.value
= b
->value
;
3650 binding
.type
= b
->type
;
3653 /* Add all _DECLs seen through local using-directives. */
3654 for (level
= current_binding_level
;
3655 level
->kind
!= sk_namespace
;
3656 level
= level
->level_chain
)
3657 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
3659 /* Give up because of error. */
3660 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3662 /* Add all _DECLs seen through global using-directives. */
3663 /* XXX local and global using lists should work equally. */
3667 if (!lookup_using_namespace (name
, &binding
,
3668 DECL_NAMESPACE_USING (siter
),
3670 /* Give up because of error. */
3671 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3672 if (siter
== scope
) break;
3673 siter
= CP_DECL_CONTEXT (siter
);
3676 val
= select_decl (&binding
, flags
);
3677 if (scope
== global_namespace
)
3680 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3683 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3684 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3687 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3688 declaration found. If no suitable declaration can be found,
3689 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3690 neither a class-type nor a namespace a diagnostic is issued. */
3693 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
3697 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3699 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3701 flags
|= LOOKUP_COMPLAIN
;
3703 flags
|= LOOKUP_PREFER_TYPES
;
3704 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
3705 return select_decl (&binding
, flags
);
3707 else if (is_aggr_type (scope
, complain
))
3710 t
= lookup_member (scope
, name
, 2, is_type_p
);
3715 return error_mark_node
;
3718 /* Subroutine of unqualified_namespace_lookup:
3719 Add the bindings of NAME in used namespaces to VAL.
3720 We are currently looking for names in namespace SCOPE, so we
3721 look through USINGS for using-directives of namespaces
3722 which have SCOPE as a common ancestor with the current scope.
3723 Returns false on errors. */
3726 lookup_using_namespace (tree name
, struct scope_binding
*val
,
3727 tree usings
, tree scope
, int flags
)
3730 timevar_push (TV_NAME_LOOKUP
);
3731 /* Iterate over all used namespaces in current, searching for using
3732 directives of scope. */
3733 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
3734 if (TREE_VALUE (iter
) == scope
)
3736 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
3738 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
3739 /* Resolve ambiguities. */
3741 ambiguous_decl (name
, val
, val1
, flags
);
3743 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
->value
!= error_mark_node
);
3747 Accepts the NAME to lookup and its qualifying SCOPE.
3748 Returns the name/type pair found into the cxx_binding *RESULT,
3749 or false on error. */
3752 qualified_lookup_using_namespace (tree name
, tree scope
,
3753 struct scope_binding
*result
, int flags
)
3755 /* Maintain a list of namespaces visited... */
3756 tree seen
= NULL_TREE
;
3757 /* ... and a list of namespace yet to see. */
3758 tree todo
= NULL_TREE
;
3759 tree todo_maybe
= NULL_TREE
;
3761 timevar_push (TV_NAME_LOOKUP
);
3762 /* Look through namespace aliases. */
3763 scope
= ORIGINAL_NAMESPACE (scope
);
3764 while (scope
&& result
->value
!= error_mark_node
)
3766 cxx_binding
*binding
=
3767 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3768 seen
= tree_cons (scope
, NULL_TREE
, seen
);
3770 ambiguous_decl (name
, result
, binding
, flags
);
3772 /* Consider strong using directives always, and non-strong ones
3773 if we haven't found a binding yet. ??? Shouldn't we consider
3774 non-strong ones if the initial RESULT is non-NULL, but the
3775 binding in the given namespace is? */
3776 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
3777 usings
= TREE_CHAIN (usings
))
3778 /* If this was a real directive, and we have not seen it. */
3779 if (!TREE_INDIRECT_USING (usings
))
3781 /* Try to avoid queuing the same namespace more than once,
3782 the exception being when a namespace was already
3783 enqueued for todo_maybe and then a strong using is
3784 found for it. We could try to remove it from
3785 todo_maybe, but it's probably not worth the effort. */
3786 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
))
3787 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3788 && !purpose_member (TREE_PURPOSE (usings
), todo
))
3789 todo
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
, todo
);
3790 else if ((!result
->value
&& !result
->type
)
3791 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3792 && !purpose_member (TREE_PURPOSE (usings
), todo
)
3793 && !purpose_member (TREE_PURPOSE (usings
), todo_maybe
))
3794 todo_maybe
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
,
3799 scope
= TREE_PURPOSE (todo
);
3800 todo
= TREE_CHAIN (todo
);
3803 && (!result
->value
&& !result
->type
))
3805 scope
= TREE_PURPOSE (todo_maybe
);
3806 todo
= TREE_CHAIN (todo_maybe
);
3807 todo_maybe
= NULL_TREE
;
3810 scope
= NULL_TREE
; /* If there never was a todo list. */
3812 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
->value
!= error_mark_node
);
3815 /* Return the innermost non-namespace binding for NAME from a scope
3816 containing BINDING, or, if BINDING is NULL, the current scope. If
3817 CLASS_P is false, then class bindings are ignored. */
3820 outer_binding (tree name
,
3821 cxx_binding
*binding
,
3826 cxx_scope
*outer_scope
;
3830 scope
= binding
->scope
->level_chain
;
3831 outer
= binding
->previous
;
3835 scope
= current_binding_level
;
3836 outer
= IDENTIFIER_BINDING (name
);
3838 outer_scope
= outer
? outer
->scope
: NULL
;
3840 /* Because we create class bindings lazily, we might be missing a
3841 class binding for NAME. If there are any class binding levels
3842 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3843 declared, we must lookup NAME in those class scopes. */
3845 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
3847 if (scope
->kind
== sk_class
)
3849 cxx_binding
*class_binding
;
3851 class_binding
= get_class_binding (name
, scope
);
3854 /* Thread this new class-scope binding onto the
3855 IDENTIFIER_BINDING list so that future lookups
3857 class_binding
->previous
= outer
;
3859 binding
->previous
= class_binding
;
3861 IDENTIFIER_BINDING (name
) = class_binding
;
3862 return class_binding
;
3865 scope
= scope
->level_chain
;
3871 /* Return the innermost block-scope or class-scope value binding for
3872 NAME, or NULL_TREE if there is no such binding. */
3875 innermost_non_namespace_value (tree name
)
3877 cxx_binding
*binding
;
3878 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
3879 return binding
? binding
->value
: NULL_TREE
;
3882 /* Look up NAME in the current binding level and its superiors in the
3883 namespace of variables, functions and typedefs. Return a ..._DECL
3884 node of some kind representing its definition if there is only one
3885 such declaration, or return a TREE_LIST with all the overloaded
3886 definitions if there are many, or return 0 if it is undefined.
3887 Hidden name, either friend declaration or built-in function, are
3890 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3891 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3892 Otherwise we prefer non-TYPE_DECLs.
3894 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3895 BLOCK_P is false, bindings in block scopes are ignored. */
3898 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
3899 int namespaces_only
, int flags
)
3902 tree val
= NULL_TREE
;
3904 timevar_push (TV_NAME_LOOKUP
);
3905 /* Conversion operators are handled specially because ordinary
3906 unqualified name lookup will not find template conversion
3908 if (IDENTIFIER_TYPENAME_P (name
))
3910 struct cp_binding_level
*level
;
3912 for (level
= current_binding_level
;
3913 level
&& level
->kind
!= sk_namespace
;
3914 level
= level
->level_chain
)
3919 /* A conversion operator can only be declared in a class
3921 if (level
->kind
!= sk_class
)
3924 /* Lookup the conversion operator in the class. */
3925 class_type
= level
->this_entity
;
3926 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
3928 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, operators
);
3931 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3934 flags
|= lookup_flags (prefer_type
, namespaces_only
);
3936 /* First, look in non-namespace scopes. */
3938 if (current_class_type
== NULL_TREE
)
3941 if (block_p
|| !nonclass
)
3942 for (iter
= outer_binding (name
, NULL
, !nonclass
);
3944 iter
= outer_binding (name
, iter
, !nonclass
))
3948 /* Skip entities we don't want. */
3949 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
3952 /* If this is the kind of thing we're looking for, we're done. */
3953 if (qualify_lookup (iter
->value
, flags
)
3954 && !hidden_name_p (iter
->value
))
3955 binding
= iter
->value
;
3956 else if ((flags
& LOOKUP_PREFER_TYPES
)
3957 && qualify_lookup (iter
->type
, flags
)
3958 && !hidden_name_p (iter
->type
))
3959 binding
= iter
->type
;
3961 binding
= NULL_TREE
;
3970 /* Now lookup in namespace scopes. */
3972 val
= unqualified_namespace_lookup (name
, flags
);
3974 /* If we have a single function from a using decl, pull it out. */
3975 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
3976 val
= OVL_FUNCTION (val
);
3978 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3982 lookup_name_nonclass (tree name
)
3984 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
3988 lookup_function_nonclass (tree name
, tree args
, bool block_p
)
3991 lookup_arg_dependent (name
,
3992 lookup_name_real (name
, 0, 1, block_p
, 0,
3998 lookup_name (tree name
)
4000 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4004 lookup_name_prefer_type (tree name
, int prefer_type
)
4006 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
4007 0, LOOKUP_COMPLAIN
);
4010 /* Look up NAME for type used in elaborated name specifier in
4011 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4012 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4013 name, more scopes are checked if cleanup or template parameter
4014 scope is encountered.
4016 Unlike lookup_name_real, we make sure that NAME is actually
4017 declared in the desired scope, not from inheritance, nor using
4018 directive. For using declaration, there is DR138 still waiting
4019 to be resolved. Hidden name coming from an earlier friend
4020 declaration is also returned.
4022 A TYPE_DECL best matching the NAME is returned. Catching error
4023 and issuing diagnostics are caller's responsibility. */
4026 lookup_type_scope (tree name
, tag_scope scope
)
4028 cxx_binding
*iter
= NULL
;
4029 tree val
= NULL_TREE
;
4031 timevar_push (TV_NAME_LOOKUP
);
4033 /* Look in non-namespace scope first. */
4034 if (current_binding_level
->kind
!= sk_namespace
)
4035 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4036 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4038 /* Check if this is the kind of thing we're looking for.
4039 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4040 base class. For ITER->VALUE, we can simply use
4041 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4044 We check ITER->TYPE before ITER->VALUE in order to handle
4045 typedef struct C {} C;
4048 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4049 && (scope
!= ts_current
4050 || LOCAL_BINDING_P (iter
)
4051 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4053 else if ((scope
!= ts_current
4054 || !INHERITED_VALUE_BINDING_P (iter
))
4055 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4062 /* Look in namespace scope. */
4065 iter
= cxx_scope_find_binding_for_name
4066 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4070 /* If this is the kind of thing we're looking for, we're done. */
4071 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4073 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4079 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4080 and template parameter scopes. */
4083 struct cp_binding_level
*b
= current_binding_level
;
4086 if (iter
->scope
== b
)
4087 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4089 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
)
4091 else if (b
->kind
== sk_class
4092 && scope
== ts_within_enclosing_non_class
)
4099 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4102 /* Similar to `lookup_name' but look only in the innermost non-class
4106 lookup_name_innermost_nonclass_level (tree name
)
4108 struct cp_binding_level
*b
;
4111 timevar_push (TV_NAME_LOOKUP
);
4112 b
= innermost_nonclass_level ();
4114 if (b
->kind
== sk_namespace
)
4116 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4118 /* extern "C" function() */
4119 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4122 else if (IDENTIFIER_BINDING (name
)
4123 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4125 cxx_binding
*binding
;
4126 binding
= IDENTIFIER_BINDING (name
);
4129 if (binding
->scope
== b
4130 && !(TREE_CODE (binding
->value
) == VAR_DECL
4131 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4132 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
->value
);
4134 if (b
->kind
== sk_cleanup
)
4141 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4144 /* Like lookup_name_innermost_nonclass_level, but for types. */
4147 lookup_type_current_level (tree name
)
4151 timevar_push (TV_NAME_LOOKUP
);
4152 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4154 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4155 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4157 struct cp_binding_level
*b
= current_binding_level
;
4160 if (purpose_member (name
, b
->type_shadowed
))
4161 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
4162 REAL_IDENTIFIER_TYPE_VALUE (name
));
4163 if (b
->kind
== sk_cleanup
)
4170 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4173 /* [basic.lookup.koenig] */
4174 /* A nonzero return value in the functions below indicates an error. */
4185 static bool arg_assoc (struct arg_lookup
*, tree
);
4186 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4187 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4188 static bool add_function (struct arg_lookup
*, tree
);
4189 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4190 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4191 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4193 /* Add a function to the lookup structure.
4194 Returns true on error. */
4197 add_function (struct arg_lookup
*k
, tree fn
)
4199 /* We used to check here to see if the function was already in the list,
4200 but that's O(n^2), which is just too expensive for function lookup.
4201 Now we deal with the occasional duplicate in joust. In doing this, we
4202 assume that the number of duplicates will be small compared to the
4203 total number of functions being compared, which should usually be the
4206 /* We must find only functions, or exactly one non-function. */
4209 else if (fn
== k
->functions
)
4211 else if (is_overloaded_fn (k
->functions
) && is_overloaded_fn (fn
))
4212 k
->functions
= build_overload (fn
, k
->functions
);
4215 tree f1
= OVL_CURRENT (k
->functions
);
4217 if (is_overloaded_fn (f1
))
4219 fn
= f1
; f1
= f2
; f2
= fn
;
4221 error ("%q+D is not a function,", f1
);
4222 error (" conflict with %q+D", f2
);
4223 error (" in call to %qD", k
->name
);
4230 /* Returns true iff CURRENT has declared itself to be an associated
4231 namespace of SCOPE via a strong using-directive (or transitive chain
4232 thereof). Both are namespaces. */
4235 is_associated_namespace (tree current
, tree scope
)
4237 tree seen
= NULL_TREE
;
4238 tree todo
= NULL_TREE
;
4242 if (scope
== current
)
4244 seen
= tree_cons (scope
, NULL_TREE
, seen
);
4245 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4246 if (!purpose_member (TREE_PURPOSE (t
), seen
))
4247 todo
= tree_cons (TREE_PURPOSE (t
), NULL_TREE
, todo
);
4250 scope
= TREE_PURPOSE (todo
);
4251 todo
= TREE_CHAIN (todo
);
4258 /* Return whether FN is a friend of an associated class of ARG. */
4261 friend_of_associated_class_p (tree arg
, tree fn
)
4267 else if (type_unknown_p (arg
))
4270 type
= TREE_TYPE (arg
);
4272 /* If TYPE is a class, the class itself and all base classes are
4273 associated classes. */
4274 if (CLASS_TYPE_P (type
))
4276 if (is_friend (type
, fn
))
4279 if (TYPE_BINFO (type
))
4281 tree binfo
, base_binfo
;
4284 for (binfo
= TYPE_BINFO (type
), i
= 0;
4285 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
4287 if (is_friend (BINFO_TYPE (base_binfo
), fn
))
4292 /* If TYPE is a class member, the class of which it is a member is
4293 an associated class. */
4294 if ((CLASS_TYPE_P (type
)
4295 || TREE_CODE (type
) == UNION_TYPE
4296 || TREE_CODE (type
) == ENUMERAL_TYPE
)
4297 && TYPE_CONTEXT (type
)
4298 && CLASS_TYPE_P (TYPE_CONTEXT (type
))
4299 && is_friend (TYPE_CONTEXT (type
), fn
))
4305 /* Add functions of a namespace to the lookup structure.
4306 Returns true on error. */
4309 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4313 if (purpose_member (scope
, k
->namespaces
))
4315 k
->namespaces
= tree_cons (scope
, NULL_TREE
, k
->namespaces
);
4317 /* Check out our super-users. */
4318 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4319 value
= TREE_CHAIN (value
))
4320 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4323 value
= namespace_binding (k
->name
, scope
);
4327 for (; value
; value
= OVL_NEXT (value
))
4329 /* We don't want to find arbitrary hidden functions via argument
4330 dependent lookup. We only want to find friends of associated
4332 if (hidden_name_p (OVL_CURRENT (value
)))
4336 for (args
= k
->args
; args
; args
= TREE_CHAIN (args
))
4337 if (friend_of_associated_class_p (TREE_VALUE (args
),
4338 OVL_CURRENT (value
)))
4344 if (add_function (k
, OVL_CURRENT (value
)))
4351 /* Adds everything associated with a template argument to the lookup
4352 structure. Returns true on error. */
4355 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4357 /* [basic.lookup.koenig]
4359 If T is a template-id, its associated namespaces and classes are
4360 ... the namespaces and classes associated with the types of the
4361 template arguments provided for template type parameters
4362 (excluding template template parameters); the namespaces in which
4363 any template template arguments are defined; and the classes in
4364 which any member templates used as template template arguments
4365 are defined. [Note: non-type template arguments do not
4366 contribute to the set of associated namespaces. ] */
4368 /* Consider first template template arguments. */
4369 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4370 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
4372 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
4374 tree ctx
= CP_DECL_CONTEXT (arg
);
4376 /* It's not a member template. */
4377 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4378 return arg_assoc_namespace (k
, ctx
);
4379 /* Otherwise, it must be member template. */
4381 return arg_assoc_class (k
, ctx
);
4383 /* It's not a template template argument, but it is a type template
4385 else if (TYPE_P (arg
))
4386 return arg_assoc_type (k
, arg
);
4387 /* It's a non-type template argument. */
4392 /* Adds everything associated with class to the lookup structure.
4393 Returns true on error. */
4396 arg_assoc_class (struct arg_lookup
*k
, tree type
)
4398 tree list
, friends
, context
;
4401 /* Backend build structures, such as __builtin_va_list, aren't
4402 affected by all this. */
4403 if (!CLASS_TYPE_P (type
))
4406 if (purpose_member (type
, k
->classes
))
4408 k
->classes
= tree_cons (type
, NULL_TREE
, k
->classes
);
4410 context
= decl_namespace_context (type
);
4411 if (arg_assoc_namespace (k
, context
))
4414 if (TYPE_BINFO (type
))
4416 /* Process baseclasses. */
4417 tree binfo
, base_binfo
;
4419 for (binfo
= TYPE_BINFO (type
), i
= 0;
4420 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4421 if (arg_assoc_class (k
, BINFO_TYPE (base_binfo
)))
4425 /* Process friends. */
4426 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
4427 list
= TREE_CHAIN (list
))
4428 if (k
->name
== FRIEND_NAME (list
))
4429 for (friends
= FRIEND_DECLS (list
); friends
;
4430 friends
= TREE_CHAIN (friends
))
4432 tree fn
= TREE_VALUE (friends
);
4434 /* Only interested in global functions with potentially hidden
4435 (i.e. unqualified) declarations. */
4436 if (CP_DECL_CONTEXT (fn
) != context
)
4438 /* Template specializations are never found by name lookup.
4439 (Templates themselves can be found, but not template
4440 specializations.) */
4441 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
4443 if (add_function (k
, fn
))
4447 /* Process template arguments. */
4448 if (CLASSTYPE_TEMPLATE_INFO (type
)
4449 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
4451 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
4452 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
4453 arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
));
4459 /* Adds everything associated with a given type.
4460 Returns 1 on error. */
4463 arg_assoc_type (struct arg_lookup
*k
, tree type
)
4465 /* As we do not get the type of non-type dependent expressions
4466 right, we can end up with such things without a type. */
4470 if (TYPE_PTRMEM_P (type
))
4472 /* Pointer to member: associate class type and value type. */
4473 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
4475 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
4477 else switch (TREE_CODE (type
))
4490 if (TYPE_PTRMEMFUNC_P (type
))
4491 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
4492 return arg_assoc_class (k
, type
);
4494 case REFERENCE_TYPE
:
4496 return arg_assoc_type (k
, TREE_TYPE (type
));
4499 return arg_assoc_namespace (k
, decl_namespace_context (type
));
4501 /* The basetype is referenced in the first arg type, so just
4504 /* Associate the parameter types. */
4505 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
4507 /* Associate the return type. */
4508 return arg_assoc_type (k
, TREE_TYPE (type
));
4509 case TEMPLATE_TYPE_PARM
:
4510 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4515 gcc_assert (type
== unknown_type_node
);
4523 /* Adds everything associated with arguments. Returns true on error. */
4526 arg_assoc_args (struct arg_lookup
*k
, tree args
)
4528 for (; args
; args
= TREE_CHAIN (args
))
4529 if (arg_assoc (k
, TREE_VALUE (args
)))
4534 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4537 arg_assoc (struct arg_lookup
*k
, tree n
)
4539 if (n
== error_mark_node
)
4543 return arg_assoc_type (k
, n
);
4545 if (! type_unknown_p (n
))
4546 return arg_assoc_type (k
, TREE_TYPE (n
));
4548 if (TREE_CODE (n
) == ADDR_EXPR
)
4549 n
= TREE_OPERAND (n
, 0);
4550 if (TREE_CODE (n
) == COMPONENT_REF
)
4551 n
= TREE_OPERAND (n
, 1);
4552 if (TREE_CODE (n
) == OFFSET_REF
)
4553 n
= TREE_OPERAND (n
, 1);
4554 while (TREE_CODE (n
) == TREE_LIST
)
4556 if (TREE_CODE (n
) == BASELINK
)
4557 n
= BASELINK_FUNCTIONS (n
);
4559 if (TREE_CODE (n
) == FUNCTION_DECL
)
4560 return arg_assoc_type (k
, TREE_TYPE (n
));
4561 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
4563 /* [basic.lookup.koenig]
4565 If T is a template-id, its associated namespaces and classes
4566 are the namespace in which the template is defined; for
4567 member templates, the member template's class... */
4568 tree
template = TREE_OPERAND (n
, 0);
4569 tree args
= TREE_OPERAND (n
, 1);
4573 if (TREE_CODE (template) == COMPONENT_REF
)
4574 template = TREE_OPERAND (template, 1);
4576 /* First, the template. There may actually be more than one if
4577 this is an overloaded function template. But, in that case,
4578 we only need the first; all the functions will be in the same
4580 template = OVL_CURRENT (template);
4582 ctx
= CP_DECL_CONTEXT (template);
4584 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4586 if (arg_assoc_namespace (k
, ctx
) == 1)
4589 /* It must be a member template. */
4590 else if (arg_assoc_class (k
, ctx
) == 1)
4593 /* Now the arguments. */
4595 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
4596 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
4599 else if (TREE_CODE (n
) == OVERLOAD
)
4601 for (; n
; n
= OVL_CHAIN (n
))
4602 if (arg_assoc_type (k
, TREE_TYPE (OVL_FUNCTION (n
))))
4609 /* Performs Koenig lookup depending on arguments, where fns
4610 are the functions found in normal lookup. */
4613 lookup_arg_dependent (tree name
, tree fns
, tree args
)
4615 struct arg_lookup k
;
4617 timevar_push (TV_NAME_LOOKUP
);
4619 /* Remove any hidden friend functions from the list of functions
4620 found so far. They will be added back by arg_assoc_class as
4622 fns
= remove_hidden_names (fns
);
4627 k
.classes
= NULL_TREE
;
4629 /* We previously performed an optimization here by setting
4630 NAMESPACES to the current namespace when it was safe. However, DR
4631 164 says that namespaces that were already searched in the first
4632 stage of template processing are searched again (potentially
4633 picking up later definitions) in the second stage. */
4634 k
.namespaces
= NULL_TREE
;
4636 arg_assoc_args (&k
, args
);
4637 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, k
.functions
);
4640 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4641 changed (i.e. there was already a directive), or the fresh
4642 TREE_LIST otherwise. */
4645 push_using_directive (tree used
)
4647 tree ud
= current_binding_level
->using_directives
;
4648 tree iter
, ancestor
;
4650 timevar_push (TV_NAME_LOOKUP
);
4651 /* Check if we already have this. */
4652 if (purpose_member (used
, ud
) != NULL_TREE
)
4653 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4655 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4656 ud
= current_binding_level
->using_directives
;
4657 ud
= tree_cons (used
, ancestor
, ud
);
4658 current_binding_level
->using_directives
= ud
;
4660 /* Recursively add all namespaces used. */
4661 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4662 push_using_directive (TREE_PURPOSE (iter
));
4664 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ud
);
4667 /* The type TYPE is being declared. If it is a class template, or a
4668 specialization of a class template, do any processing required and
4669 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4670 being declared a friend. B is the binding level at which this TYPE
4673 Returns the TYPE_DECL for TYPE, which may have been altered by this
4677 maybe_process_template_type_declaration (tree type
, int is_friend
,
4680 tree decl
= TYPE_NAME (type
);
4682 if (processing_template_parmlist
)
4683 /* You can't declare a new template type in a template parameter
4684 list. But, you can declare a non-template type:
4686 template <class A*> struct S;
4688 is a forward-declaration of `A'. */
4690 else if (b
->kind
== sk_namespace
4691 && current_binding_level
->kind
!= sk_namespace
)
4692 /* If this new type is being injected into a containing scope,
4693 then it's not a template type. */
4697 gcc_assert (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ENUMERAL_TYPE
);
4699 if (processing_template_decl
)
4701 /* This may change after the call to
4702 push_template_decl_real, but we want the original value. */
4703 tree name
= DECL_NAME (decl
);
4705 decl
= push_template_decl_real (decl
, is_friend
);
4706 /* If the current binding level is the binding level for the
4707 template parameters (see the comment in
4708 begin_template_parm_list) and the enclosing level is a class
4709 scope, and we're not looking at a friend, push the
4710 declaration of the member class into the class scope. In the
4711 friend case, push_template_decl will already have put the
4712 friend into global scope, if appropriate. */
4713 if (TREE_CODE (type
) != ENUMERAL_TYPE
4714 && !is_friend
&& b
->kind
== sk_template_parms
4715 && b
->level_chain
->kind
== sk_class
)
4717 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
4719 if (!COMPLETE_TYPE_P (current_class_type
))
4721 maybe_add_class_template_decl_list (current_class_type
,
4722 type
, /*friend_p=*/0);
4723 /* Put this UTD in the table of UTDs for the class. */
4724 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
4725 CLASSTYPE_NESTED_UTDS (current_class_type
) =
4726 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4728 binding_table_insert
4729 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
4738 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4739 that the NAME is a class template, the tag is processed but not pushed.
4741 The pushed scope depend on the SCOPE parameter:
4742 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4744 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4745 non-template-parameter scope. This case is needed for forward
4747 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4748 TS_GLOBAL case except that names within template-parameter scopes
4749 are not pushed at all.
4751 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4754 pushtag (tree name
, tree type
, tag_scope scope
)
4756 struct cp_binding_level
*b
;
4759 timevar_push (TV_NAME_LOOKUP
);
4760 b
= current_binding_level
;
4761 while (/* Cleanup scopes are not scopes from the point of view of
4763 b
->kind
== sk_cleanup
4764 /* Neither are the scopes used to hold template parameters
4765 for an explicit specialization. For an ordinary template
4766 declaration, these scopes are not scopes from the point of
4767 view of the language. */
4768 || (b
->kind
== sk_template_parms
4769 && (b
->explicit_spec_p
|| scope
== ts_global
))
4770 || (b
->kind
== sk_class
4771 && (scope
!= ts_current
4772 /* We may be defining a new type in the initializer
4773 of a static member variable. We allow this when
4774 not pedantic, and it is particularly useful for
4775 type punning via an anonymous union. */
4776 || COMPLETE_TYPE_P (b
->this_entity
))))
4779 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
4781 /* Do C++ gratuitous typedefing. */
4782 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
4786 tree context
= TYPE_CONTEXT (type
);
4790 tree cs
= current_scope ();
4792 if (scope
== ts_current
)
4794 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
4795 /* When declaring a friend class of a local class, we want
4796 to inject the newly named class into the scope
4797 containing the local class, not the namespace
4799 context
= decl_function_context (get_type_decl (cs
));
4802 context
= current_namespace
;
4804 if (b
->kind
== sk_class
4805 || (b
->kind
== sk_template_parms
4806 && b
->level_chain
->kind
== sk_class
))
4809 if (current_lang_name
== lang_name_java
)
4810 TYPE_FOR_JAVA (type
) = 1;
4812 tdef
= create_implicit_typedef (name
, type
);
4813 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
4814 if (scope
== ts_within_enclosing_non_class
)
4816 /* This is a friend. Make this TYPE_DECL node hidden from
4817 ordinary name lookup. Its corresponding TEMPLATE_DECL
4818 will be marked in push_template_decl_real. */
4819 retrofit_lang_decl (tdef
);
4820 DECL_ANTICIPATED (tdef
) = 1;
4821 DECL_FRIEND_P (tdef
) = 1;
4824 decl
= maybe_process_template_type_declaration
4825 (type
, scope
== ts_within_enclosing_non_class
, b
);
4826 if (decl
== error_mark_node
)
4827 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
4830 set_identifier_type_value_with_scope (name
, tdef
, b
);
4832 if (b
->kind
== sk_class
)
4834 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4835 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4836 class. But if it's a member template class, we want
4837 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4839 finish_member_declaration (decl
);
4841 pushdecl_class_level (decl
);
4843 else if (b
->kind
!= sk_template_parms
)
4844 decl
= pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
4846 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
4848 /* If this is a local class, keep track of it. We need this
4849 information for name-mangling, and so that it is possible to
4850 find all function definitions in a translation unit in a
4851 convenient way. (It's otherwise tricky to find a member
4852 function definition it's only pointed to from within a local
4854 if (TYPE_CONTEXT (type
)
4855 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
4856 VEC_safe_push (tree
, gc
, local_classes
, type
);
4858 if (b
->kind
== sk_class
4859 && !COMPLETE_TYPE_P (current_class_type
))
4861 maybe_add_class_template_decl_list (current_class_type
,
4862 type
, /*friend_p=*/0);
4864 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
4865 CLASSTYPE_NESTED_UTDS (current_class_type
)
4866 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4868 binding_table_insert
4869 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
4872 decl
= TYPE_NAME (type
);
4873 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
4874 TYPE_STUB_DECL (type
) = decl
;
4876 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, type
);
4879 /* Subroutines for reverting temporarily to top-level for instantiation
4880 of templates and such. We actually need to clear out the class- and
4881 local-value slots of all identifiers, so that only the global values
4882 are at all visible. Simply setting current_binding_level to the global
4883 scope isn't enough, because more binding levels may be pushed. */
4884 struct saved_scope
*scope_chain
;
4886 /* If ID has not already been marked, add an appropriate binding to
4890 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
4892 cxx_saved_binding
*saved
;
4894 if (!id
|| !IDENTIFIER_BINDING (id
))
4897 if (IDENTIFIER_MARKED (id
))
4900 IDENTIFIER_MARKED (id
) = 1;
4902 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
4903 saved
->identifier
= id
;
4904 saved
->binding
= IDENTIFIER_BINDING (id
);
4905 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
4906 IDENTIFIER_BINDING (id
) = NULL
;
4910 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
4914 timevar_push (TV_NAME_LOOKUP
);
4915 for (t
= names
; t
; t
= TREE_CHAIN (t
))
4919 if (TREE_CODE (t
) == TREE_LIST
)
4920 id
= TREE_PURPOSE (t
);
4924 store_binding (id
, old_bindings
);
4926 timevar_pop (TV_NAME_LOOKUP
);
4929 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4930 objects, rather than a TREE_LIST. */
4933 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
4934 VEC(cxx_saved_binding
,gc
) **old_bindings
)
4937 cp_class_binding
*cb
;
4939 timevar_push (TV_NAME_LOOKUP
);
4940 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
4941 store_binding (cb
->identifier
, old_bindings
);
4942 timevar_pop (TV_NAME_LOOKUP
);
4946 push_to_top_level (void)
4948 struct saved_scope
*s
;
4949 struct cp_binding_level
*b
;
4950 cxx_saved_binding
*sb
;
4954 timevar_push (TV_NAME_LOOKUP
);
4955 s
= GGC_CNEW (struct saved_scope
);
4957 b
= scope_chain
? current_binding_level
: 0;
4959 /* If we're in the middle of some function, save our state. */
4963 push_function_context_to (NULL_TREE
);
4968 if (scope_chain
&& previous_class_level
)
4969 store_class_bindings (previous_class_level
->class_shadowed
,
4972 /* Have to include the global scope, because class-scope decls
4973 aren't listed anywhere useful. */
4974 for (; b
; b
= b
->level_chain
)
4978 /* Template IDs are inserted into the global level. If they were
4979 inserted into namespace level, finish_file wouldn't find them
4980 when doing pending instantiations. Therefore, don't stop at
4981 namespace level, but continue until :: . */
4982 if (global_scope_p (b
))
4985 store_bindings (b
->names
, &s
->old_bindings
);
4986 /* We also need to check class_shadowed to save class-level type
4987 bindings, since pushclass doesn't fill in b->names. */
4988 if (b
->kind
== sk_class
)
4989 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
4991 /* Unwind type-value slots back to top level. */
4992 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
4993 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
4996 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, sb
); ++i
)
4997 IDENTIFIER_MARKED (sb
->identifier
) = 0;
4999 s
->prev
= scope_chain
;
5001 s
->need_pop_function_context
= need_pop
;
5002 s
->function_decl
= current_function_decl
;
5003 s
->skip_evaluation
= skip_evaluation
;
5006 current_function_decl
= NULL_TREE
;
5007 current_lang_base
= VEC_alloc (tree
, gc
, 10);
5008 current_lang_name
= lang_name_cplusplus
;
5009 current_namespace
= global_namespace
;
5010 skip_evaluation
= 0;
5011 timevar_pop (TV_NAME_LOOKUP
);
5015 pop_from_top_level (void)
5017 struct saved_scope
*s
= scope_chain
;
5018 cxx_saved_binding
*saved
;
5021 timevar_push (TV_NAME_LOOKUP
);
5022 /* Clear out class-level bindings cache. */
5023 if (previous_class_level
)
5024 invalidate_class_lookup_cache ();
5026 current_lang_base
= 0;
5028 scope_chain
= s
->prev
;
5029 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, saved
); ++i
)
5031 tree id
= saved
->identifier
;
5033 IDENTIFIER_BINDING (id
) = saved
->binding
;
5034 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
5037 /* If we were in the middle of compiling a function, restore our
5039 if (s
->need_pop_function_context
)
5040 pop_function_context_from (NULL_TREE
);
5041 current_function_decl
= s
->function_decl
;
5042 skip_evaluation
= s
->skip_evaluation
;
5043 timevar_pop (TV_NAME_LOOKUP
);
5046 /* Pop off extraneous binding levels left over due to syntax errors.
5048 We don't pop past namespaces, as they might be valid. */
5051 pop_everything (void)
5053 if (ENABLE_SCOPE_CHECKING
)
5054 verbatim ("XXX entering pop_everything ()\n");
5055 while (!toplevel_bindings_p ())
5057 if (current_binding_level
->kind
== sk_class
)
5058 pop_nested_class ();
5062 if (ENABLE_SCOPE_CHECKING
)
5063 verbatim ("XXX leaving pop_everything ()\n");
5066 /* Emit debugging information for using declarations and directives.
5067 If input tree is overloaded fn then emit debug info for all
5071 cp_emit_debug_info_for_using (tree t
, tree context
)
5073 /* Don't try to emit any debug information if we have errors. */
5074 if (sorrycount
|| errorcount
)
5077 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5078 of a builtin function. */
5079 if (TREE_CODE (t
) == FUNCTION_DECL
5080 && DECL_EXTERNAL (t
)
5081 && DECL_BUILT_IN (t
))
5084 /* Do not supply context to imported_module_or_decl, if
5085 it is a global namespace. */
5086 if (context
== global_namespace
)
5087 context
= NULL_TREE
;
5090 t
= BASELINK_FUNCTIONS (t
);
5092 /* FIXME: Handle TEMPLATE_DECLs. */
5093 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
5094 if (TREE_CODE (t
) != TEMPLATE_DECL
)
5095 (*debug_hooks
->imported_module_or_decl
) (t
, context
);
5098 #include "gt-cp-name-lookup.h"