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);
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 a built-in that has not yet been declared,
441 pretend it is not there at all. */
442 || (TREE_CODE (bval
) == FUNCTION_DECL
443 && DECL_ANTICIPATED (bval
)))
444 binding
->value
= decl
;
445 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
447 /* The old binding was a type name. It was placed in
448 VALUE field because it was thought, at the point it was
449 declared, to be the only entity with such a name. Move the
450 type name into the type slot; it is now hidden by the new
452 binding
->type
= bval
;
453 binding
->value
= decl
;
454 binding
->value_is_inherited
= false;
456 else if (TREE_CODE (bval
) == TYPE_DECL
457 && TREE_CODE (decl
) == TYPE_DECL
458 && DECL_NAME (decl
) == DECL_NAME (bval
)
459 && binding
->scope
->kind
!= sk_class
460 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
461 /* If either type involves template parameters, we must
462 wait until instantiation. */
463 || uses_template_parms (TREE_TYPE (decl
))
464 || uses_template_parms (TREE_TYPE (bval
))))
465 /* We have two typedef-names, both naming the same type to have
466 the same name. In general, this is OK because of:
470 In a given scope, a typedef specifier can be used to redefine
471 the name of any type declared in that scope to refer to the
472 type to which it already refers.
474 However, in class scopes, this rule does not apply due to the
475 stricter language in [class.mem] prohibiting redeclarations of
478 /* There can be two block-scope declarations of the same variable,
479 so long as they are `extern' declarations. However, there cannot
480 be two declarations of the same static data member:
484 A member shall not be declared twice in the
485 member-specification. */
486 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
487 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
488 && !DECL_CLASS_SCOPE_P (decl
))
490 duplicate_decls (decl
, binding
->value
);
493 else if (TREE_CODE (decl
) == NAMESPACE_DECL
494 && TREE_CODE (bval
) == NAMESPACE_DECL
495 && DECL_NAMESPACE_ALIAS (decl
)
496 && DECL_NAMESPACE_ALIAS (bval
)
497 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
500 In a declarative region, a namespace-alias-definition can be
501 used to redefine a namespace-alias declared in that declarative
502 region to refer only to the namespace to which it already
507 error ("declaration of %q#D", decl
);
508 error ("conflicts with previous declaration %q+#D", bval
);
512 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
515 /* Add DECL to the list of things declared in B. */
518 add_decl_to_level (tree decl
, cxx_scope
*b
)
520 if (TREE_CODE (decl
) == NAMESPACE_DECL
521 && !DECL_NAMESPACE_ALIAS (decl
))
523 TREE_CHAIN (decl
) = b
->namespaces
;
524 b
->namespaces
= decl
;
526 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
528 TREE_CHAIN (decl
) = b
->vtables
;
533 /* We build up the list in reverse order, and reverse it later if
535 TREE_CHAIN (decl
) = b
->names
;
539 /* If appropriate, add decl to separate list of statics. We
540 include extern variables because they might turn out to be
541 static later. It's OK for this list to contain a few false
543 if (b
->kind
== sk_namespace
)
544 if ((TREE_CODE (decl
) == VAR_DECL
545 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
546 || (TREE_CODE (decl
) == FUNCTION_DECL
547 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
548 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
552 /* Record a decl-node X as belonging to the current lexical scope.
553 Check for errors (such as an incompatible declaration for the same
554 name already seen in the same scope).
556 Returns either X or an old decl for the same name.
557 If an old decl is returned, it may have been smashed
558 to agree with what X says. */
565 int need_new_binding
;
567 timevar_push (TV_NAME_LOOKUP
);
569 need_new_binding
= 1;
571 if (DECL_TEMPLATE_PARM_P (x
))
572 /* Template parameters have no context; they are not X::T even
573 when declared within a class or namespace. */
577 if (current_function_decl
&& x
!= current_function_decl
578 /* A local declaration for a function doesn't constitute
580 && TREE_CODE (x
) != FUNCTION_DECL
581 /* A local declaration for an `extern' variable is in the
582 scope of the current namespace, not the current
584 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
585 && !DECL_CONTEXT (x
))
586 DECL_CONTEXT (x
) = current_function_decl
;
588 /* If this is the declaration for a namespace-scope function,
589 but the declaration itself is in a local scope, mark the
591 if (TREE_CODE (x
) == FUNCTION_DECL
592 && DECL_NAMESPACE_SCOPE_P (x
)
593 && current_function_decl
594 && x
!= current_function_decl
)
595 DECL_LOCAL_FUNCTION_P (x
) = 1;
598 name
= DECL_NAME (x
);
601 int different_binding_level
= 0;
603 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
604 name
= TREE_OPERAND (name
, 0);
606 /* In case this decl was explicitly namespace-qualified, look it
607 up in its namespace context. */
608 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
609 t
= namespace_binding (name
, DECL_CONTEXT (x
));
611 t
= lookup_name_innermost_nonclass_level (name
);
613 /* [basic.link] If there is a visible declaration of an entity
614 with linkage having the same name and type, ignoring entities
615 declared outside the innermost enclosing namespace scope, the
616 block scope declaration declares that same entity and
617 receives the linkage of the previous declaration. */
618 if (! t
&& current_function_decl
&& x
!= current_function_decl
619 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
620 && DECL_EXTERNAL (x
))
622 /* Look in block scope. */
623 t
= innermost_non_namespace_value (name
);
624 /* Or in the innermost namespace. */
626 t
= namespace_binding (name
, DECL_CONTEXT (x
));
627 /* Does it have linkage? Note that if this isn't a DECL, it's an
628 OVERLOAD, which is OK. */
629 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
632 different_binding_level
= 1;
635 /* If we are declaring a function, and the result of name-lookup
636 was an OVERLOAD, look for an overloaded instance that is
637 actually the same as the function we are declaring. (If
638 there is one, we have to merge our declaration with the
639 previous declaration.) */
640 if (t
&& TREE_CODE (t
) == OVERLOAD
)
644 if (TREE_CODE (x
) == FUNCTION_DECL
)
645 for (match
= t
; match
; match
= OVL_NEXT (match
))
647 if (decls_match (OVL_CURRENT (match
), x
))
651 /* Just choose one. */
655 t
= OVL_CURRENT (match
);
660 if (t
&& t
!= error_mark_node
)
662 if (different_binding_level
)
664 if (decls_match (x
, t
))
665 /* The standard only says that the local extern
666 inherits linkage from the previous decl; in
667 particular, default args are not shared. We must
668 also tell cgraph to treat these decls as the same,
669 or we may neglect to emit an "unused" static - we
670 do this by making the DECL_UIDs equal, which should
671 be viewed as a kludge. FIXME. */
673 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
674 DECL_UID (x
) = DECL_UID (t
);
677 else if (TREE_CODE (t
) == PARM_DECL
)
679 gcc_assert (DECL_CONTEXT (t
));
681 /* Check for duplicate params. */
682 if (duplicate_decls (x
, t
))
683 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
685 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
686 || DECL_FUNCTION_TEMPLATE_P (x
))
687 && is_overloaded_fn (t
))
688 /* Don't do anything just yet. */;
689 else if (t
== wchar_decl_node
)
691 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
692 pedwarn ("redeclaration of %<wchar_t%> as %qT",
695 /* Throw away the redeclaration. */
696 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
700 tree olddecl
= duplicate_decls (x
, t
);
702 /* If the redeclaration failed, we can stop at this
704 if (olddecl
== error_mark_node
)
705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
709 if (TREE_CODE (t
) == TYPE_DECL
)
710 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
711 else if (TREE_CODE (t
) == FUNCTION_DECL
)
712 check_default_args (t
);
714 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
716 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
718 /* A redeclaration of main, but not a duplicate of the
723 This function shall not be overloaded. */
724 error ("invalid redeclaration of %q+D", t
);
726 /* We don't try to push this declaration since that
728 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
733 check_template_shadow (x
);
735 /* If this is a function conjured up by the backend, massage it
736 so it looks friendly. */
737 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
739 retrofit_lang_decl (x
);
740 SET_DECL_LANGUAGE (x
, lang_c
);
743 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
745 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
748 if (!namespace_bindings_p ())
749 /* We do not need to create a binding for this name;
750 push_overloaded_decl will have already done so if
752 need_new_binding
= 0;
754 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
756 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
758 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
759 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
762 /* If declaring a type as a typedef, copy the type (unless we're
763 at line 0), and install this TYPE_DECL as the new type's typedef
764 name. See the extensive comment in ../c-decl.c (pushdecl). */
765 if (TREE_CODE (x
) == TYPE_DECL
)
767 tree type
= TREE_TYPE (x
);
768 if (DECL_IS_BUILTIN (x
))
770 if (TYPE_NAME (type
) == 0)
771 TYPE_NAME (type
) = x
;
773 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
774 /* We don't want to copy the type when all we're
775 doing is making a TYPE_DECL for the purposes of
777 && (!TYPE_NAME (type
)
778 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
780 DECL_ORIGINAL_TYPE (x
) = type
;
781 type
= build_variant_type_copy (type
);
782 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
783 TYPE_NAME (type
) = x
;
784 TREE_TYPE (x
) = type
;
787 if (type
!= error_mark_node
789 && TYPE_IDENTIFIER (type
))
790 set_identifier_type_value (DECL_NAME (x
), x
);
793 /* Multiple external decls of the same identifier ought to match.
795 We get warnings about inline functions where they are defined.
796 We get warnings about other functions from push_overloaded_decl.
798 Avoid duplicate warnings where they are used. */
799 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
803 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
804 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
805 decl
= OVL_FUNCTION (decl
);
807 if (decl
&& decl
!= error_mark_node
808 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
809 /* If different sort of thing, we already gave an error. */
810 && TREE_CODE (decl
) == TREE_CODE (x
)
811 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
813 pedwarn ("type mismatch with previous external decl of %q#D", x
);
814 pedwarn ("previous external decl of %q+#D", decl
);
818 /* This name is new in its binding level.
819 Install the new declaration and return it. */
820 if (namespace_bindings_p ())
822 /* Install a global value. */
824 /* If the first global decl has external linkage,
825 warn if we later see static one. */
826 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
827 TREE_PUBLIC (name
) = 1;
829 /* Bind the name for the entity. */
830 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
832 && (TREE_CODE (x
) == TYPE_DECL
833 || TREE_CODE (x
) == VAR_DECL
834 || TREE_CODE (x
) == ALIAS_DECL
835 || TREE_CODE (x
) == NAMESPACE_DECL
836 || TREE_CODE (x
) == CONST_DECL
837 || TREE_CODE (x
) == TEMPLATE_DECL
))
838 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
840 /* If new decl is `static' and an `extern' was seen previously,
842 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
843 warn_extern_redeclared_static (x
, t
);
847 /* Here to install a non-global value. */
848 tree oldlocal
= innermost_non_namespace_value (name
);
849 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
851 if (need_new_binding
)
853 push_local_binding (name
, x
, 0);
854 /* Because push_local_binding will hook X on to the
855 current_binding_level's name list, we don't want to
856 do that again below. */
857 need_new_binding
= 0;
860 /* If this is a TYPE_DECL, push it into the type value slot. */
861 if (TREE_CODE (x
) == TYPE_DECL
)
862 set_identifier_type_value (name
, x
);
864 /* Clear out any TYPE_DECL shadowed by a namespace so that
865 we won't think this is a type. The C struct hack doesn't
866 go through namespaces. */
867 if (TREE_CODE (x
) == NAMESPACE_DECL
)
868 set_identifier_type_value (name
, NULL_TREE
);
875 && TREE_CODE (oldlocal
) == VAR_DECL
876 && DECL_DEAD_FOR_LOCAL (oldlocal
))
877 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
879 if (oldlocal
== NULL_TREE
)
880 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
883 /* If this is an extern function declaration, see if we
884 have a global definition or declaration for the function. */
885 if (oldlocal
== NULL_TREE
887 && oldglobal
!= NULL_TREE
888 && TREE_CODE (x
) == FUNCTION_DECL
889 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
891 /* We have one. Their types must agree. */
892 if (decls_match (x
, oldglobal
))
896 warning (0, "extern declaration of %q#D doesn't match", x
);
897 warning (0, "global declaration %q+#D", oldglobal
);
900 /* If we have a local external declaration,
901 and no file-scope declaration has yet been seen,
902 then if we later have a file-scope decl it must not be static. */
903 if (oldlocal
== NULL_TREE
904 && oldglobal
== NULL_TREE
907 TREE_PUBLIC (name
) = 1;
909 /* Warn if shadowing an argument at the top level of the body. */
910 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
911 /* Inline decls shadow nothing. */
912 && !DECL_FROM_INLINE (x
)
913 && TREE_CODE (oldlocal
) == PARM_DECL
914 /* Don't check the `this' parameter. */
915 && !DECL_ARTIFICIAL (oldlocal
))
919 /* Don't complain if it's from an enclosing function. */
920 if (DECL_CONTEXT (oldlocal
) == current_function_decl
921 && TREE_CODE (x
) != PARM_DECL
)
923 /* Go to where the parms should be and see if we find
925 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
927 /* Skip the ctor/dtor cleanup level. */
931 if (b
->kind
== sk_function_parms
)
933 error ("declaration of %q#D shadows a parameter", x
);
938 if (warn_shadow
&& !err
)
940 warning (0, "declaration of %q#D shadows a parameter", x
);
941 warning (0, "%Jshadowed declaration is here", oldlocal
);
945 /* Maybe warn if shadowing something else. */
946 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
947 /* No shadow warnings for internally generated vars. */
948 && ! DECL_ARTIFICIAL (x
)
949 /* No shadow warnings for vars made for inlining. */
950 && ! DECL_FROM_INLINE (x
))
954 if (current_class_ptr
)
955 member
= lookup_member (current_class_type
,
958 /*want_type=*/false);
962 if (member
&& !TREE_STATIC (member
))
964 /* Location of previous decl is not useful in this case. */
965 warning (0, "declaration of %qD shadows a member of 'this'",
968 else if (oldlocal
!= NULL_TREE
969 && TREE_CODE (oldlocal
) == VAR_DECL
)
971 warning (0, "declaration of %qD shadows a previous local", x
);
972 warning (0, "%Jshadowed declaration is here", oldlocal
);
974 else if (oldglobal
!= NULL_TREE
975 && TREE_CODE (oldglobal
) == VAR_DECL
)
976 /* XXX shadow warnings in outer-more namespaces */
978 warning (0, "declaration of %qD shadows a global declaration",
980 warning (0, "%Jshadowed declaration is here", oldglobal
);
985 if (TREE_CODE (x
) == FUNCTION_DECL
)
986 check_default_args (x
);
988 if (TREE_CODE (x
) == VAR_DECL
)
989 maybe_register_incomplete_var (x
);
992 if (need_new_binding
)
993 add_decl_to_level (x
,
994 DECL_NAMESPACE_SCOPE_P (x
)
995 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
996 : current_binding_level
);
998 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1001 /* Enter DECL into the symbol table, if that's appropriate. Returns
1002 DECL, or a modified version thereof. */
1005 maybe_push_decl (tree decl
)
1007 tree type
= TREE_TYPE (decl
);
1009 /* Add this decl to the current binding level, but not if it comes
1010 from another scope, e.g. a static member variable. TEM may equal
1011 DECL or it may be a previous decl of the same name. */
1012 if (decl
== error_mark_node
1013 || (TREE_CODE (decl
) != PARM_DECL
1014 && DECL_CONTEXT (decl
) != NULL_TREE
1015 /* Definitions of namespace members outside their namespace are
1017 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
1018 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1019 || TREE_CODE (type
) == UNKNOWN_TYPE
1020 /* The declaration of a template specialization does not affect
1021 the functions available for overload resolution, so we do not
1023 || (TREE_CODE (decl
) == FUNCTION_DECL
1024 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1027 return pushdecl (decl
);
1030 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1031 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1032 doesn't really belong to this binding level, that it got here
1033 through a using-declaration. */
1036 push_local_binding (tree id
, tree decl
, int flags
)
1038 struct cp_binding_level
*b
;
1040 /* Skip over any local classes. This makes sense if we call
1041 push_local_binding with a friend decl of a local class. */
1042 b
= innermost_nonclass_level ();
1044 if (lookup_name_innermost_nonclass_level (id
))
1046 /* Supplement the existing binding. */
1047 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1048 /* It didn't work. Something else must be bound at this
1049 level. Do not add DECL to the list of things to pop
1054 /* Create a new binding. */
1055 push_binding (id
, decl
, b
);
1057 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1058 /* We must put the OVERLOAD into a TREE_LIST since the
1059 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1060 decls that got here through a using-declaration. */
1061 decl
= build_tree_list (NULL_TREE
, decl
);
1063 /* And put DECL on the list of things declared by the current
1065 add_decl_to_level (decl
, b
);
1068 /* Check to see whether or not DECL is a variable that would have been
1069 in scope under the ARM, but is not in scope under the ANSI/ISO
1070 standard. If so, issue an error message. If name lookup would
1071 work in both cases, but return a different result, this function
1072 returns the result of ANSI/ISO lookup. Otherwise, it returns
1076 check_for_out_of_scope_variable (tree decl
)
1080 /* We only care about out of scope variables. */
1081 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1084 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1085 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1086 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1087 && DECL_DEAD_FOR_LOCAL (shadowed
))
1088 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1089 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1091 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1094 if (!DECL_ERROR_REPORTED (decl
))
1096 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1097 warning (0, " matches this %q+D under ISO standard rules",
1099 warning (0, " matches this %q+D under old rules", decl
);
1100 DECL_ERROR_REPORTED (decl
) = 1;
1105 /* If we have already complained about this declaration, there's no
1106 need to do it again. */
1107 if (DECL_ERROR_REPORTED (decl
))
1110 DECL_ERROR_REPORTED (decl
) = 1;
1112 if (TREE_TYPE (decl
) == error_mark_node
)
1115 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1117 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1119 error (" cannot use obsolete binding at %q+D because "
1120 "it has a destructor", decl
);
1121 return error_mark_node
;
1125 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1127 pedwarn (" using obsolete binding at %q+D", decl
);
1133 /* true means unconditionally make a BLOCK for the next level pushed. */
1135 static bool keep_next_level_flag
;
1137 static int binding_depth
= 0;
1138 static int is_class_level
= 0;
1145 for (i
= 0; i
< depth
* 2; i
++)
1149 /* Return a string describing the kind of SCOPE we have. */
1151 cxx_scope_descriptor (cxx_scope
*scope
)
1153 /* The order of this table must match the "scope_kind"
1155 static const char* scope_kind_names
[] = {
1161 "function-parameter-scope",
1164 "template-parameter-scope",
1165 "template-explicit-spec-scope"
1167 const scope_kind kind
= scope
->explicit_spec_p
1168 ? sk_template_spec
: scope
->kind
;
1170 return scope_kind_names
[kind
];
1173 /* Output a debugging information about SCOPE when performing
1176 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1178 const char *desc
= cxx_scope_descriptor (scope
);
1179 if (scope
->this_entity
)
1180 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1181 scope
->this_entity
, (void *) scope
, line
);
1183 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1186 /* Return the estimated initial size of the hashtable of a NAMESPACE
1189 static inline size_t
1190 namespace_scope_ht_size (tree ns
)
1192 tree name
= DECL_NAME (ns
);
1194 return name
== std_identifier
1195 ? NAMESPACE_STD_HT_SIZE
1196 : (name
== global_scope_name
1197 ? GLOBAL_SCOPE_HT_SIZE
1198 : NAMESPACE_ORDINARY_HT_SIZE
);
1201 /* A chain of binding_level structures awaiting reuse. */
1203 static GTY((deletable
)) struct cp_binding_level
*free_binding_level
;
1205 /* Insert SCOPE as the innermost binding level. */
1208 push_binding_level (struct cp_binding_level
*scope
)
1210 /* Add it to the front of currently active scopes stack. */
1211 scope
->level_chain
= current_binding_level
;
1212 current_binding_level
= scope
;
1213 keep_next_level_flag
= false;
1215 if (ENABLE_SCOPE_CHECKING
)
1217 scope
->binding_depth
= binding_depth
;
1218 indent (binding_depth
);
1219 cxx_scope_debug (scope
, input_line
, "push");
1225 /* Create a new KIND scope and make it the top of the active scopes stack.
1226 ENTITY is the scope of the associated C++ entity (namespace, class,
1227 function); it is NULL otherwise. */
1230 begin_scope (scope_kind kind
, tree entity
)
1234 /* Reuse or create a struct for this binding level. */
1235 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1237 scope
= free_binding_level
;
1238 free_binding_level
= scope
->level_chain
;
1241 scope
= GGC_NEW (cxx_scope
);
1242 memset (scope
, 0, sizeof (cxx_scope
));
1244 scope
->this_entity
= entity
;
1245 scope
->more_cleanups_ok
= true;
1252 case sk_template_spec
:
1253 scope
->explicit_spec_p
= true;
1254 kind
= sk_template_parms
;
1256 case sk_template_parms
:
1262 case sk_function_parms
:
1263 scope
->keep
= keep_next_level_flag
;
1267 NAMESPACE_LEVEL (entity
) = scope
;
1268 scope
->static_decls
=
1269 VEC_alloc (tree
, gc
,
1270 DECL_NAME (entity
) == std_identifier
1271 || DECL_NAME (entity
) == global_scope_name
1276 /* Should not happen. */
1282 push_binding_level (scope
);
1287 /* We're about to leave current scope. Pop the top of the stack of
1288 currently active scopes. Return the enclosing scope, now active. */
1293 cxx_scope
*scope
= current_binding_level
;
1295 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1296 current_binding_level
= class_binding_level
;
1298 /* We cannot leave a scope, if there are none left. */
1299 if (NAMESPACE_LEVEL (global_namespace
))
1300 gcc_assert (!global_scope_p (scope
));
1302 if (ENABLE_SCOPE_CHECKING
)
1304 indent (--binding_depth
);
1305 cxx_scope_debug (scope
, input_line
, "leave");
1306 if (is_class_level
!= (scope
== class_binding_level
))
1308 indent (binding_depth
);
1309 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1314 /* Move one nesting level up. */
1315 current_binding_level
= scope
->level_chain
;
1317 /* Namespace-scopes are left most probably temporarily, not
1318 completely; they can be reopen later, e.g. in namespace-extension
1319 or any name binding activity that requires us to resume a
1320 namespace. For classes, we cache some binding levels. For other
1321 scopes, we just make the structure available for reuse. */
1322 if (scope
->kind
!= sk_namespace
1323 && scope
->kind
!= sk_class
)
1325 scope
->level_chain
= free_binding_level
;
1326 gcc_assert (!ENABLE_SCOPE_CHECKING
1327 || scope
->binding_depth
== binding_depth
);
1328 free_binding_level
= scope
;
1331 /* Find the innermost enclosing class scope, and reset
1332 CLASS_BINDING_LEVEL appropriately. */
1333 if (scope
->kind
== sk_class
)
1335 class_binding_level
= NULL
;
1336 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1337 if (scope
->kind
== sk_class
)
1339 class_binding_level
= scope
;
1344 return current_binding_level
;
1348 resume_scope (struct cp_binding_level
* b
)
1350 /* Resuming binding levels is meant only for namespaces,
1351 and those cannot nest into classes. */
1352 gcc_assert (!class_binding_level
);
1353 /* Also, resuming a non-directly nested namespace is a no-no. */
1354 gcc_assert (b
->level_chain
== current_binding_level
);
1355 current_binding_level
= b
;
1356 if (ENABLE_SCOPE_CHECKING
)
1358 b
->binding_depth
= binding_depth
;
1359 indent (binding_depth
);
1360 cxx_scope_debug (b
, input_line
, "resume");
1366 /* Return the innermost binding level that is not for a class scope. */
1369 innermost_nonclass_level (void)
1373 b
= current_binding_level
;
1374 while (b
->kind
== sk_class
)
1380 /* We're defining an object of type TYPE. If it needs a cleanup, but
1381 we're not allowed to add any more objects with cleanups to the current
1382 scope, create a new binding level. */
1385 maybe_push_cleanup_level (tree type
)
1387 if (type
!= error_mark_node
1388 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1389 && current_binding_level
->more_cleanups_ok
== 0)
1391 begin_scope (sk_cleanup
, NULL
);
1392 current_binding_level
->statement_list
= push_stmt_list ();
1396 /* Nonzero if we are currently in the global binding level. */
1399 global_bindings_p (void)
1401 return global_scope_p (current_binding_level
);
1404 /* True if we are currently in a toplevel binding level. This
1405 means either the global binding level or a namespace in a toplevel
1406 binding level. Since there are no non-toplevel namespace levels,
1407 this really means any namespace or template parameter level. We
1408 also include a class whose context is toplevel. */
1411 toplevel_bindings_p (void)
1413 struct cp_binding_level
*b
= innermost_nonclass_level ();
1415 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1418 /* True if this is a namespace scope, or if we are defining a class
1419 which is itself at namespace scope, or whose enclosing class is
1420 such a class, etc. */
1423 namespace_bindings_p (void)
1425 struct cp_binding_level
*b
= innermost_nonclass_level ();
1427 return b
->kind
== sk_namespace
;
1430 /* True if the current level needs to have a BLOCK made. */
1435 return (current_binding_level
->blocks
!= NULL_TREE
1436 || current_binding_level
->keep
1437 || current_binding_level
->kind
== sk_cleanup
1438 || current_binding_level
->names
!= NULL_TREE
);
1441 /* Returns the kind of the innermost scope. */
1444 innermost_scope_kind (void)
1446 return current_binding_level
->kind
;
1449 /* Returns true if this scope was created to store template parameters. */
1452 template_parm_scope_p (void)
1454 return innermost_scope_kind () == sk_template_parms
;
1457 /* If KEEP is true, make a BLOCK node for the next binding level,
1458 unconditionally. Otherwise, use the normal logic to decide whether
1459 or not to create a BLOCK. */
1462 keep_next_level (bool keep
)
1464 keep_next_level_flag
= keep
;
1467 /* Return the list of declarations of the current level.
1468 Note that this list is in reverse order unless/until
1469 you nreverse it; and when you do nreverse it, you must
1470 store the result back using `storedecls' or you will lose. */
1475 return current_binding_level
->names
;
1478 /* For debugging. */
1479 static int no_print_functions
= 0;
1480 static int no_print_builtins
= 0;
1483 print_binding_level (struct cp_binding_level
* lvl
)
1487 fprintf (stderr
, " blocks=" HOST_PTR_PRINTF
, (void *) lvl
->blocks
);
1488 if (lvl
->more_cleanups_ok
)
1489 fprintf (stderr
, " more-cleanups-ok");
1490 if (lvl
->have_cleanups
)
1491 fprintf (stderr
, " have-cleanups");
1492 fprintf (stderr
, "\n");
1495 fprintf (stderr
, " names:\t");
1496 /* We can probably fit 3 names to a line? */
1497 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1499 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1501 if (no_print_builtins
1502 && (TREE_CODE (t
) == TYPE_DECL
)
1503 && DECL_IS_BUILTIN (t
))
1506 /* Function decls tend to have longer names. */
1507 if (TREE_CODE (t
) == FUNCTION_DECL
)
1514 fprintf (stderr
, "\n\t");
1517 print_node_brief (stderr
, "", t
, 0);
1518 if (t
== error_mark_node
)
1522 fprintf (stderr
, "\n");
1524 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1527 cp_class_binding
*b
;
1528 fprintf (stderr
, " class-shadowed:");
1530 VEC_iterate(cp_class_binding
, lvl
->class_shadowed
, i
, b
);
1532 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1533 fprintf (stderr
, "\n");
1535 if (lvl
->type_shadowed
)
1537 fprintf (stderr
, " type-shadowed:");
1538 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1540 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1542 fprintf (stderr
, "\n");
1547 print_other_binding_stack (struct cp_binding_level
*stack
)
1549 struct cp_binding_level
*level
;
1550 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1552 fprintf (stderr
, "binding level " HOST_PTR_PRINTF
"\n", (void *) level
);
1553 print_binding_level (level
);
1558 print_binding_stack (void)
1560 struct cp_binding_level
*b
;
1561 fprintf (stderr
, "current_binding_level=" HOST_PTR_PRINTF
1562 "\nclass_binding_level=" HOST_PTR_PRINTF
1563 "\nNAMESPACE_LEVEL (global_namespace)=" HOST_PTR_PRINTF
"\n",
1564 (void *) current_binding_level
, (void *) class_binding_level
,
1565 (void *) NAMESPACE_LEVEL (global_namespace
));
1566 if (class_binding_level
)
1568 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1569 if (b
== current_binding_level
)
1572 b
= class_binding_level
;
1574 b
= current_binding_level
;
1577 b
= current_binding_level
;
1578 print_other_binding_stack (b
);
1579 fprintf (stderr
, "global:\n");
1580 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1583 /* Return the type associated with id. */
1586 identifier_type_value (tree id
)
1588 timevar_push (TV_NAME_LOOKUP
);
1589 /* There is no type with that name, anywhere. */
1590 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1591 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1592 /* This is not the type marker, but the real thing. */
1593 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1594 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, REAL_IDENTIFIER_TYPE_VALUE (id
));
1595 /* Have to search for it. It must be on the global level, now.
1596 Ask lookup_name not to return non-types. */
1597 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1599 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, TREE_TYPE (id
));
1600 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1603 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1604 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1607 identifier_global_value (tree t
)
1609 return IDENTIFIER_GLOBAL_VALUE (t
);
1612 /* Push a definition of struct, union or enum tag named ID. into
1613 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1614 the tag ID is not already defined. */
1617 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1621 if (b
->kind
!= sk_namespace
)
1623 /* Shadow the marker, not the real thing, so that the marker
1624 gets restored later. */
1625 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1627 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1628 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1629 TREE_TYPE (b
->type_shadowed
) = type
;
1633 cxx_binding
*binding
=
1634 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1637 supplement_binding (binding
, decl
);
1639 binding
->value
= decl
;
1641 /* Store marker instead of real type. */
1642 type
= global_type_node
;
1644 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1647 /* As set_identifier_type_value_with_scope, but using
1648 current_binding_level. */
1651 set_identifier_type_value (tree id
, tree decl
)
1653 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1656 /* Return the name for the constructor (or destructor) for the
1657 specified class TYPE. When given a template, this routine doesn't
1658 lose the specialization. */
1661 constructor_name_full (tree type
)
1663 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1666 /* Return the name for the constructor (or destructor) for the
1667 specified class. When given a template, return the plain
1668 unspecialized name. */
1671 constructor_name (tree type
)
1674 name
= constructor_name_full (type
);
1675 if (IDENTIFIER_TEMPLATE (name
))
1676 name
= IDENTIFIER_TEMPLATE (name
);
1680 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1683 constructor_name_p (tree name
, tree type
)
1690 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1693 ctor_name
= constructor_name_full (type
);
1694 if (name
== ctor_name
)
1696 if (IDENTIFIER_TEMPLATE (ctor_name
)
1697 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1702 /* Counter used to create anonymous type names. */
1704 static GTY(()) int anon_cnt
;
1706 /* Return an IDENTIFIER which can be used as a name for
1707 anonymous structs and unions. */
1710 make_anon_name (void)
1714 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1715 return get_identifier (buf
);
1718 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1720 static inline cxx_binding
*
1721 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1723 timevar_push (TV_NAME_LOOKUP
);
1725 for (; binding
!= NULL
; binding
= binding
->previous
)
1726 if (binding
->scope
== scope
)
1727 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
);
1729 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, (cxx_binding
*)0);
1732 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1734 static inline cxx_binding
*
1735 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1737 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1740 /* Fold-in case where NAME is used only once. */
1741 if (scope
== b
->scope
&& b
->previous
== NULL
)
1743 return find_binding (scope
, b
);
1748 /* Always returns a binding for name in scope. If no binding is
1749 found, make a new one. */
1751 static cxx_binding
*
1752 binding_for_name (cxx_scope
*scope
, tree name
)
1754 cxx_binding
*result
;
1756 result
= cxx_scope_find_binding_for_name (scope
, name
);
1759 /* Not found, make a new one. */
1760 result
= cxx_binding_make (NULL
, NULL
);
1761 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1762 result
->scope
= scope
;
1763 result
->is_local
= false;
1764 result
->value_is_inherited
= false;
1765 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1769 /* Insert another USING_DECL into the current binding level, returning
1770 this declaration. If this is a redeclaration, do nothing, and
1771 return NULL_TREE if this not in namespace scope (in namespace
1772 scope, a using decl might extend any previous bindings). */
1775 push_using_decl (tree scope
, tree name
)
1779 timevar_push (TV_NAME_LOOKUP
);
1780 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
1781 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1782 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
1783 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
1786 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
1787 namespace_bindings_p () ? decl
: NULL_TREE
);
1788 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
1789 USING_DECL_SCOPE (decl
) = scope
;
1790 TREE_CHAIN (decl
) = current_binding_level
->usings
;
1791 current_binding_level
->usings
= decl
;
1792 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1795 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1796 caller to set DECL_CONTEXT properly. */
1799 pushdecl_with_scope (tree x
, cxx_scope
*level
)
1801 struct cp_binding_level
*b
;
1802 tree function_decl
= current_function_decl
;
1804 timevar_push (TV_NAME_LOOKUP
);
1805 current_function_decl
= NULL_TREE
;
1806 if (level
->kind
== sk_class
)
1808 b
= class_binding_level
;
1809 class_binding_level
= level
;
1810 pushdecl_class_level (x
);
1811 class_binding_level
= b
;
1815 b
= current_binding_level
;
1816 current_binding_level
= level
;
1818 current_binding_level
= b
;
1820 current_function_decl
= function_decl
;
1821 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1824 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1825 other definitions already in place. We get around this by making
1826 the value of the identifier point to a list of all the things that
1827 want to be referenced by that name. It is then up to the users of
1828 that name to decide what to do with that list.
1830 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1831 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1833 FLAGS is a bitwise-or of the following values:
1834 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1836 PUSH_USING: DECL is being pushed as the result of a using
1839 The value returned may be a previous declaration if we guessed wrong
1840 about what language DECL should belong to (C or C++). Otherwise,
1841 it's always DECL (and never something that's not a _DECL). */
1844 push_overloaded_decl (tree decl
, int flags
)
1846 tree name
= DECL_NAME (decl
);
1849 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
1851 timevar_push (TV_NAME_LOOKUP
);
1853 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
1855 old
= lookup_name_innermost_nonclass_level (name
);
1859 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
1861 tree t
= TREE_TYPE (old
);
1862 if (IS_AGGR_TYPE (t
) && warn_shadow
1863 && (! DECL_IN_SYSTEM_HEADER (decl
)
1864 || ! DECL_IN_SYSTEM_HEADER (old
)))
1865 warning (0, "%q#D hides constructor for %q#T", decl
, t
);
1868 else if (is_overloaded_fn (old
))
1872 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
1874 tree fn
= OVL_CURRENT (tmp
);
1876 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
1877 && !(flags
& PUSH_USING
)
1878 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1879 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
1880 && ! decls_match (fn
, decl
))
1881 error ("%q#D conflicts with previous using declaration %q#D",
1884 if (duplicate_decls (decl
, fn
) == fn
)
1885 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, fn
);
1888 /* We don't overload implicit built-ins. duplicate_decls()
1889 may fail to merge the decls if the new decl is e.g. a
1890 template function. */
1891 if (TREE_CODE (old
) == FUNCTION_DECL
1892 && DECL_ANTICIPATED (old
))
1895 else if (old
== error_mark_node
)
1896 /* Ignore the undefined symbol marker. */
1900 error ("previous non-function declaration %q+#D", old
);
1901 error ("conflicts with function declaration %q#D", decl
);
1902 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1906 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
1907 /* If it's a using declaration, we always need to build an OVERLOAD,
1908 because it's the only way to remember that the declaration comes
1909 from 'using', and have the lookup behave correctly. */
1910 || (flags
& PUSH_USING
))
1912 if (old
&& TREE_CODE (old
) != OVERLOAD
)
1913 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
1915 new_binding
= ovl_cons (decl
, old
);
1916 if (flags
& PUSH_USING
)
1917 OVL_USED (new_binding
) = 1;
1920 /* NAME is not ambiguous. */
1924 set_namespace_binding (name
, current_namespace
, new_binding
);
1927 /* We only create an OVERLOAD if there was a previous binding at
1928 this level, or if decl is a template. In the former case, we
1929 need to remove the old binding and replace it with the new
1930 binding. We must also run through the NAMES on the binding
1931 level where the name was bound to update the chain. */
1933 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
1937 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
1939 d
= &TREE_CHAIN (*d
))
1941 || (TREE_CODE (*d
) == TREE_LIST
1942 && TREE_VALUE (*d
) == old
))
1944 if (TREE_CODE (*d
) == TREE_LIST
)
1945 /* Just replace the old binding with the new. */
1946 TREE_VALUE (*d
) = new_binding
;
1948 /* Build a TREE_LIST to wrap the OVERLOAD. */
1949 *d
= tree_cons (NULL_TREE
, new_binding
,
1952 /* And update the cxx_binding node. */
1953 IDENTIFIER_BINDING (name
)->value
= new_binding
;
1954 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1957 /* We should always find a previous binding in this case. */
1961 /* Install the new binding. */
1962 push_local_binding (name
, new_binding
, flags
);
1965 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1968 /* Check a non-member using-declaration. Return the name and scope
1969 being used, and the USING_DECL, or NULL_TREE on failure. */
1972 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
1974 /* [namespace.udecl]
1975 A using-declaration for a class member shall be a
1976 member-declaration. */
1979 error ("%qT is not a namespace", scope
);
1982 else if (scope
== error_mark_node
)
1985 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
1988 A using-declaration shall not name a template-id. */
1989 error ("a using-declaration cannot specify a template-id. "
1990 "Try %<using %D%>", name
);
1994 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
1996 error ("namespace %qD not allowed in using-declaration", decl
);
2000 if (TREE_CODE (decl
) == SCOPE_REF
)
2002 /* It's a nested name with template parameter dependent scope.
2003 This can only be using-declaration for class member. */
2004 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2008 if (is_overloaded_fn (decl
))
2009 decl
= get_first_fn (decl
);
2011 gcc_assert (DECL_P (decl
));
2013 /* Make a USING_DECL. */
2014 return push_using_decl (scope
, name
);
2017 /* Process local and global using-declarations. */
2020 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2021 tree
*newval
, tree
*newtype
)
2023 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2025 *newval
= *newtype
= NULL_TREE
;
2026 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2030 if (!decls
.value
&& !decls
.type
)
2032 error ("%qD not declared", name
);
2036 /* It is impossible to overload a built-in function; any explicit
2037 declaration eliminates the built-in declaration. So, if OLDVAL
2038 is a built-in, then we can just pretend it isn't there. */
2040 && TREE_CODE (oldval
) == FUNCTION_DECL
2041 && DECL_ANTICIPATED (oldval
))
2044 /* Check for using functions. */
2045 if (decls
.value
&& is_overloaded_fn (decls
.value
))
2049 if (oldval
&& !is_overloaded_fn (oldval
))
2051 if (!DECL_IMPLICIT_TYPEDEF_P (oldval
))
2052 error ("%qD is already declared in this scope", name
);
2057 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2059 tree new_fn
= OVL_CURRENT (tmp
);
2061 /* [namespace.udecl]
2063 If a function declaration in namespace scope or block
2064 scope has the same name and the same parameter types as a
2065 function introduced by a using declaration the program is
2067 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2069 tree old_fn
= OVL_CURRENT (tmp1
);
2071 if (new_fn
== old_fn
)
2072 /* The function already exists in the current namespace. */
2074 else if (OVL_USED (tmp1
))
2075 continue; /* this is a using decl */
2076 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2077 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2079 gcc_assert (!DECL_ANTICIPATED (old_fn
));
2081 /* There was already a non-using declaration in
2082 this scope with the same parameter types. If both
2083 are the same extern "C" functions, that's ok. */
2084 if (decls_match (new_fn
, old_fn
))
2088 error ("%qD is already declared in this scope", name
);
2094 /* If we broke out of the loop, there's no reason to add
2095 this function to the using declarations for this
2100 /* If we are adding to an existing OVERLOAD, then we no
2101 longer know the type of the set of functions. */
2102 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2103 TREE_TYPE (*newval
) = unknown_type_node
;
2104 /* Add this new function to the set. */
2105 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2106 /* If there is only one function, then we use its type. (A
2107 using-declaration naming a single function can be used in
2108 contexts where overload resolution cannot be
2110 if (TREE_CODE (*newval
) != OVERLOAD
)
2112 *newval
= ovl_cons (*newval
, NULL_TREE
);
2113 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2115 OVL_USED (*newval
) = 1;
2120 *newval
= decls
.value
;
2121 if (oldval
&& !decls_match (*newval
, oldval
))
2122 error ("%qD is already declared in this scope", name
);
2125 *newtype
= decls
.type
;
2126 if (oldtype
&& *newtype
&& !same_type_p (oldtype
, *newtype
))
2128 error ("using declaration %qD introduced ambiguous type %qT",
2134 /* Process a using-declaration at function scope. */
2137 do_local_using_decl (tree decl
, tree scope
, tree name
)
2139 tree oldval
, oldtype
, newval
, newtype
;
2140 tree orig_decl
= decl
;
2142 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2143 if (decl
== NULL_TREE
)
2146 if (building_stmt_tree ()
2147 && at_function_scope_p ())
2148 add_decl_expr (decl
);
2150 oldval
= lookup_name_innermost_nonclass_level (name
);
2151 oldtype
= lookup_type_current_level (name
);
2153 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2157 if (is_overloaded_fn (newval
))
2161 /* We only need to push declarations for those functions
2162 that were not already bound in the current level.
2163 The old value might be NULL_TREE, it might be a single
2164 function, or an OVERLOAD. */
2165 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2166 term
= OVL_FUNCTION (oldval
);
2169 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2171 push_overloaded_decl (OVL_CURRENT (fn
),
2172 PUSH_LOCAL
| PUSH_USING
);
2175 push_local_binding (name
, newval
, PUSH_USING
);
2179 push_local_binding (name
, newtype
, PUSH_USING
);
2180 set_identifier_type_value (name
, newtype
);
2183 /* Emit debug info. */
2184 if (!processing_template_decl
)
2185 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2188 /* Returns true if ROOT (a namespace, class, or function) encloses
2189 CHILD. CHILD may be either a class type or a namespace. */
2192 is_ancestor (tree root
, tree child
)
2194 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2195 || TREE_CODE (root
) == FUNCTION_DECL
2196 || CLASS_TYPE_P (root
)));
2197 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2198 || CLASS_TYPE_P (child
)));
2200 /* The global namespace encloses everything. */
2201 if (root
== global_namespace
)
2206 /* If we've run out of scopes, stop. */
2209 /* If we've reached the ROOT, it encloses CHILD. */
2212 /* Go out one level. */
2214 child
= TYPE_NAME (child
);
2215 child
= DECL_CONTEXT (child
);
2219 /* Enter the class or namespace scope indicated by T suitable for name
2220 lookup. T can be arbitrary scope, not necessary nested inside the
2221 current scope. Returns a non-null scope to pop iff pop_scope
2222 should be called later to exit this scope. */
2227 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2228 push_decl_namespace (t
);
2229 else if (CLASS_TYPE_P (t
))
2231 if (!at_class_scope_p ()
2232 || !same_type_p (current_class_type
, t
))
2233 push_nested_class (t
);
2235 /* T is the same as the current scope. There is therefore no
2236 need to re-enter the scope. Since we are not actually
2237 pushing a new scope, our caller should not call
2245 /* Leave scope pushed by push_scope. */
2250 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2251 pop_decl_namespace ();
2252 else if CLASS_TYPE_P (t
)
2253 pop_nested_class ();
2256 /* Subroutine of push_inner_scope. */
2259 push_inner_scope_r (tree outer
, tree inner
)
2264 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2267 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2269 push_inner_scope_r (outer
, prev
);
2270 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2272 struct cp_binding_level
*save_template_parm
= 0;
2273 /* Temporary take out template parameter scopes. They are saved
2274 in reversed order in save_template_parm. */
2275 while (current_binding_level
->kind
== sk_template_parms
)
2277 struct cp_binding_level
*b
= current_binding_level
;
2278 current_binding_level
= b
->level_chain
;
2279 b
->level_chain
= save_template_parm
;
2280 save_template_parm
= b
;
2283 resume_scope (NAMESPACE_LEVEL (inner
));
2284 current_namespace
= inner
;
2286 /* Restore template parameter scopes. */
2287 while (save_template_parm
)
2289 struct cp_binding_level
*b
= save_template_parm
;
2290 save_template_parm
= b
->level_chain
;
2291 b
->level_chain
= current_binding_level
;
2292 current_binding_level
= b
;
2299 /* Enter the scope INNER from current scope. INNER must be a scope
2300 nested inside current scope. This works with both name lookup and
2301 pushing name into scope. In case a template parameter scope is present,
2302 namespace is pushed under the template parameter scope according to
2303 name lookup rule in 14.6.1/6.
2305 Return the former current scope suitable for pop_inner_scope. */
2308 push_inner_scope (tree inner
)
2310 tree outer
= current_scope ();
2312 outer
= current_namespace
;
2314 push_inner_scope_r (outer
, inner
);
2318 /* Exit the current scope INNER back to scope OUTER. */
2321 pop_inner_scope (tree outer
, tree inner
)
2324 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2327 while (outer
!= inner
)
2329 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2331 struct cp_binding_level
*save_template_parm
= 0;
2332 /* Temporary take out template parameter scopes. They are saved
2333 in reversed order in save_template_parm. */
2334 while (current_binding_level
->kind
== sk_template_parms
)
2336 struct cp_binding_level
*b
= current_binding_level
;
2337 current_binding_level
= b
->level_chain
;
2338 b
->level_chain
= save_template_parm
;
2339 save_template_parm
= b
;
2344 /* Restore template parameter scopes. */
2345 while (save_template_parm
)
2347 struct cp_binding_level
*b
= save_template_parm
;
2348 save_template_parm
= b
->level_chain
;
2349 b
->level_chain
= current_binding_level
;
2350 current_binding_level
= b
;
2356 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2360 /* Do a pushlevel for class declarations. */
2363 pushlevel_class (void)
2365 if (ENABLE_SCOPE_CHECKING
)
2368 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2371 /* ...and a poplevel for class declarations. */
2374 poplevel_class (void)
2376 struct cp_binding_level
*level
= class_binding_level
;
2377 cp_class_binding
*cb
;
2381 timevar_push (TV_NAME_LOOKUP
);
2382 gcc_assert (level
!= 0);
2384 /* If we're leaving a toplevel class, cache its binding level. */
2385 if (current_class_depth
== 1)
2386 previous_class_level
= level
;
2387 for (shadowed
= level
->type_shadowed
;
2389 shadowed
= TREE_CHAIN (shadowed
))
2390 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2392 /* Remove the bindings for all of the class-level declarations. */
2393 if (level
->class_shadowed
)
2396 VEC_iterate (cp_class_binding
, level
->class_shadowed
, i
, cb
);
2398 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
.previous
;
2399 ggc_free (level
->class_shadowed
);
2400 level
->class_shadowed
= NULL
;
2403 /* Now, pop out of the binding level which we created up in the
2404 `pushlevel_class' routine. */
2405 if (ENABLE_SCOPE_CHECKING
)
2409 timevar_pop (TV_NAME_LOOKUP
);
2412 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2413 appropriate. DECL is the value to which a name has just been
2414 bound. CLASS_TYPE is the class in which the lookup occurred. */
2417 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2420 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2424 if (TREE_CODE (decl
) == OVERLOAD
)
2425 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2428 gcc_assert (DECL_P (decl
));
2429 context
= context_for_name_lookup (decl
);
2432 if (is_properly_derived_from (class_type
, context
))
2433 INHERITED_VALUE_BINDING_P (binding
) = 1;
2435 INHERITED_VALUE_BINDING_P (binding
) = 0;
2437 else if (binding
->value
== decl
)
2438 /* We only encounter a TREE_LIST when there is an ambiguity in the
2439 base classes. Such an ambiguity can be overridden by a
2440 definition in this class. */
2441 INHERITED_VALUE_BINDING_P (binding
) = 1;
2443 INHERITED_VALUE_BINDING_P (binding
) = 0;
2446 /* Make the declaration of X appear in CLASS scope. */
2449 pushdecl_class_level (tree x
)
2452 bool is_valid
= true;
2454 timevar_push (TV_NAME_LOOKUP
);
2455 /* Get the name of X. */
2456 if (TREE_CODE (x
) == OVERLOAD
)
2457 name
= DECL_NAME (get_first_fn (x
));
2459 name
= DECL_NAME (x
);
2463 is_valid
= push_class_level_binding (name
, x
);
2464 if (TREE_CODE (x
) == TYPE_DECL
)
2465 set_identifier_type_value (name
, x
);
2467 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2469 /* If X is an anonymous aggregate, all of its members are
2470 treated as if they were members of the class containing the
2471 aggregate, for naming purposes. */
2474 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= TREE_CHAIN (f
))
2476 location_t save_location
= input_location
;
2477 input_location
= DECL_SOURCE_LOCATION (f
);
2478 if (!pushdecl_class_level (f
))
2480 input_location
= save_location
;
2483 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, is_valid
);
2486 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2487 scope. If the value returned is non-NULL, and the PREVIOUS field
2488 is not set, callers must set the PREVIOUS field explicitly. */
2490 static cxx_binding
*
2491 get_class_binding (tree name
, cxx_scope
*scope
)
2496 cxx_binding
*binding
;
2498 class_type
= scope
->this_entity
;
2500 /* Get the type binding. */
2501 type_binding
= lookup_member (class_type
, name
,
2502 /*protect=*/2, /*want_type=*/true);
2503 /* Get the value binding. */
2504 value_binding
= lookup_member (class_type
, name
,
2505 /*protect=*/2, /*want_type=*/false);
2508 && (TREE_CODE (value_binding
) == TYPE_DECL
2509 || DECL_CLASS_TEMPLATE_P (value_binding
)
2510 || (TREE_CODE (value_binding
) == TREE_LIST
2511 && TREE_TYPE (value_binding
) == error_mark_node
2512 && (TREE_CODE (TREE_VALUE (value_binding
))
2514 /* We found a type binding, even when looking for a non-type
2515 binding. This means that we already processed this binding
2518 else if (value_binding
)
2520 if (TREE_CODE (value_binding
) == TREE_LIST
2521 && TREE_TYPE (value_binding
) == error_mark_node
)
2522 /* NAME is ambiguous. */
2524 else if (BASELINK_P (value_binding
))
2525 /* NAME is some overloaded functions. */
2526 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2529 /* If we found either a type binding or a value binding, create a
2530 new binding object. */
2531 if (type_binding
|| value_binding
)
2533 binding
= new_class_binding (name
,
2537 /* This is a class-scope binding, not a block-scope binding. */
2538 LOCAL_BINDING_P (binding
) = 0;
2539 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2547 /* Make the declaration(s) of X appear in CLASS scope under the name
2548 NAME. Returns true if the binding is valid. */
2551 push_class_level_binding (tree name
, tree x
)
2553 cxx_binding
*binding
;
2557 timevar_push (TV_NAME_LOOKUP
);
2558 /* The class_binding_level will be NULL if x is a template
2559 parameter name in a member template. */
2560 if (!class_binding_level
)
2561 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2563 /* Check for invalid member names. */
2564 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2565 /* We could have been passed a tree list if this is an ambiguous
2566 declaration. If so, pull the declaration out because
2567 check_template_shadow will not handle a TREE_LIST. */
2568 if (TREE_CODE (decl
) == TREE_LIST
2569 && TREE_TYPE (decl
) == error_mark_node
)
2570 decl
= TREE_VALUE (decl
);
2572 check_template_shadow (decl
);
2576 If T is the name of a class, then each of the following shall
2577 have a name different from T:
2579 -- every static data member of class T;
2581 -- every member of class T that is itself a type;
2583 -- every enumerator of every member of class T that is an
2586 -- every member of every anonymous union that is a member of
2589 (Non-static data members were also forbidden to have the same
2590 name as T until TC1.) */
2591 if ((TREE_CODE (x
) == VAR_DECL
2592 || TREE_CODE (x
) == CONST_DECL
2593 || (TREE_CODE (x
) == TYPE_DECL
2594 && !DECL_SELF_REFERENCE_P (x
))
2595 /* A data member of an anonymous union. */
2596 || (TREE_CODE (x
) == FIELD_DECL
2597 && DECL_CONTEXT (x
) != current_class_type
))
2598 && DECL_NAME (x
) == constructor_name (current_class_type
))
2600 tree scope
= context_for_name_lookup (x
);
2601 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
2603 error ("%qD has the same name as the class in which it is "
2606 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2610 /* Get the current binding for NAME in this class, if any. */
2611 binding
= IDENTIFIER_BINDING (name
);
2612 if (!binding
|| binding
->scope
!= class_binding_level
)
2614 binding
= get_class_binding (name
, class_binding_level
);
2615 /* If a new binding was created, put it at the front of the
2616 IDENTIFIER_BINDING list. */
2619 binding
->previous
= IDENTIFIER_BINDING (name
);
2620 IDENTIFIER_BINDING (name
) = binding
;
2624 /* If there is already a binding, then we may need to update the
2626 if (binding
&& binding
->value
)
2628 tree bval
= binding
->value
;
2629 tree old_decl
= NULL_TREE
;
2631 if (INHERITED_VALUE_BINDING_P (binding
))
2633 /* If the old binding was from a base class, and was for a
2634 tag name, slide it over to make room for the new binding.
2635 The old binding is still visible if explicitly qualified
2636 with a class-key. */
2637 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2638 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2640 old_decl
= binding
->type
;
2641 binding
->type
= bval
;
2642 binding
->value
= NULL_TREE
;
2643 INHERITED_VALUE_BINDING_P (binding
) = 0;
2648 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2650 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2651 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2652 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
2654 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
2655 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2657 if (old_decl
&& binding
->scope
== class_binding_level
)
2660 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2661 here. This function is only used to register bindings
2662 from with the class definition itself. */
2663 INHERITED_VALUE_BINDING_P (binding
) = 0;
2664 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2668 /* Note that we declared this value so that we can issue an error if
2669 this is an invalid redeclaration of a name already used for some
2671 note_name_declared_in_class (name
, decl
);
2673 /* If we didn't replace an existing binding, put the binding on the
2674 stack of bindings for the identifier, and update the shadowed
2676 if (binding
&& binding
->scope
== class_binding_level
)
2677 /* Supplement the existing binding. */
2678 ok
= supplement_binding (binding
, decl
);
2681 /* Create a new binding. */
2682 push_binding (name
, decl
, class_binding_level
);
2686 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
2689 /* Process "using SCOPE::NAME" in a class scope. Return the
2690 USING_DECL created. */
2693 do_class_using_decl (tree scope
, tree name
)
2695 tree value
, decl
, binfo
;
2699 if (!scope
|| !TYPE_P (scope
))
2701 error ("using-declaration for non-member at class scope");
2705 /* Make sure the scope is a base. */
2706 dependent_p
= dependent_type_p (scope
);
2708 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
2712 if (same_type_p (current_class_type
, scope
))
2713 b_kind
= bk_same_type
;
2715 b_kind
= bk_proper_base
;
2718 if (b_kind
< bk_proper_base
)
2720 error_not_base_type (scope
, current_class_type
);
2724 /* Make sure the name is not invalid */
2725 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2727 error ("%<%T::%D%> names destructor", scope
, name
);
2730 if (constructor_name_p (name
, scope
))
2732 error ("%<%T::%D%> names constructor", scope
, name
);
2735 if (constructor_name_p (name
, current_class_type
))
2737 error ("%<%T::%D%> names constructor in %qT",
2738 scope
, name
, current_class_type
);
2743 && IDENTIFIER_OPNAME_P (name
) && dependent_type_p (TREE_TYPE (name
)))
2746 /* See if there are any members of the base. */
2749 decl
= lookup_member (binfo
, name
, 0, false);
2753 error ("no members matching %<%T::%D%> in %q#T", scope
, name
, scope
);
2757 if (BASELINK_P (decl
))
2758 /* Ignore base type this came from. */
2759 decl
= BASELINK_FUNCTIONS (decl
);
2764 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2765 USING_DECL_DECLS (value
) = decl
;
2766 USING_DECL_SCOPE (value
) = scope
;
2767 DECL_DEPENDENT_P (value
) = dependent_p
;
2773 /* Return the binding value for name in scope. */
2776 namespace_binding (tree name
, tree scope
)
2778 cxx_binding
*binding
;
2781 scope
= global_namespace
;
2783 /* Unnecessary for the global namespace because it can't be an alias. */
2784 scope
= ORIGINAL_NAMESPACE (scope
);
2786 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2788 return binding
? binding
->value
: NULL_TREE
;
2791 /* Set the binding value for name in scope. */
2794 set_namespace_binding (tree name
, tree scope
, tree val
)
2798 timevar_push (TV_NAME_LOOKUP
);
2799 if (scope
== NULL_TREE
)
2800 scope
= global_namespace
;
2801 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2802 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
2805 supplement_binding (b
, val
);
2806 timevar_pop (TV_NAME_LOOKUP
);
2809 /* Set the context of a declaration to scope. Complain if we are not
2813 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
2817 /* Get rid of namespace aliases. */
2818 scope
= ORIGINAL_NAMESPACE (scope
);
2820 /* It is ok for friends to be qualified in parallel space. */
2821 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
2822 error ("declaration of %qD not in a namespace surrounding %qD",
2824 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
2826 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2827 if (scope
== current_namespace
)
2829 if (at_namespace_scope_p ())
2830 error ("explicit qualification in declaration of %qD",
2835 /* See whether this has been declared in the namespace. */
2836 old
= namespace_binding (DECL_NAME (decl
), scope
);
2838 /* No old declaration at all. */
2840 /* A template can be explicitly specialized in any namespace. */
2841 if (processing_explicit_instantiation
)
2843 if (!is_overloaded_fn (decl
))
2844 /* Don't compare non-function decls with decls_match here, since
2845 it can't check for the correct constness at this
2846 point. pushdecl will find those errors later. */
2848 /* Since decl is a function, old should contain a function decl. */
2849 if (!is_overloaded_fn (old
))
2851 if (processing_template_decl
|| processing_specialization
)
2852 /* We have not yet called push_template_decl to turn a
2853 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2854 match. But, we'll check later, when we construct the
2857 if (is_overloaded_fn (old
))
2859 for (; old
; old
= OVL_NEXT (old
))
2860 if (decls_match (decl
, OVL_CURRENT (old
)))
2863 else if (decls_match (decl
, old
))
2866 error ("%qD should have been declared inside %qD", decl
, scope
);
2869 /* Return the namespace where the current declaration is declared. */
2872 current_decl_namespace (void)
2875 /* If we have been pushed into a different namespace, use it. */
2876 if (decl_namespace_list
)
2877 return TREE_PURPOSE (decl_namespace_list
);
2879 if (current_class_type
)
2880 result
= decl_namespace_context (current_class_type
);
2881 else if (current_function_decl
)
2882 result
= decl_namespace_context (current_function_decl
);
2884 result
= current_namespace
;
2888 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2889 select a name that is unique to this compilation unit. */
2892 push_namespace (tree name
)
2896 int implicit_use
= 0;
2899 timevar_push (TV_NAME_LOOKUP
);
2901 /* We should not get here if the global_namespace is not yet constructed
2902 nor if NAME designates the global namespace: The global scope is
2903 constructed elsewhere. */
2904 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
2908 /* The name of anonymous namespace is unique for the translation
2910 if (!anonymous_namespace_name
)
2911 anonymous_namespace_name
= get_file_function_name ('N');
2912 name
= anonymous_namespace_name
;
2913 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2915 /* Reopening anonymous namespace. */
2921 /* Check whether this is an extended namespace definition. */
2922 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2923 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2926 if (DECL_NAMESPACE_ALIAS (d
))
2928 error ("namespace alias %qD not allowed here, assuming %qD",
2929 d
, DECL_NAMESPACE_ALIAS (d
));
2930 d
= DECL_NAMESPACE_ALIAS (d
);
2937 /* Make a new namespace, binding the name to it. */
2938 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2939 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
2943 /* Clear DECL_NAME for the benefit of debugging back ends. */
2944 SET_DECL_ASSEMBLER_NAME (d
, name
);
2945 DECL_NAME (d
) = NULL_TREE
;
2947 begin_scope (sk_namespace
, d
);
2950 resume_scope (NAMESPACE_LEVEL (d
));
2953 do_using_directive (d
);
2954 /* Enter the name space. */
2955 current_namespace
= d
;
2957 timevar_pop (TV_NAME_LOOKUP
);
2960 /* Pop from the scope of the current namespace. */
2963 pop_namespace (void)
2965 gcc_assert (current_namespace
!= global_namespace
);
2966 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2967 /* The binding level is not popped, as it might be re-opened later. */
2971 /* Push into the scope of the namespace NS, even if it is deeply
2972 nested within another namespace. */
2975 push_nested_namespace (tree ns
)
2977 if (ns
== global_namespace
)
2978 push_to_top_level ();
2981 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2982 push_namespace (DECL_NAME (ns
));
2986 /* Pop back from the scope of the namespace NS, which was previously
2987 entered with push_nested_namespace. */
2990 pop_nested_namespace (tree ns
)
2992 timevar_push (TV_NAME_LOOKUP
);
2993 while (ns
!= global_namespace
)
2996 ns
= CP_DECL_CONTEXT (ns
);
2999 pop_from_top_level ();
3000 timevar_pop (TV_NAME_LOOKUP
);
3003 /* Temporarily set the namespace for the current declaration. */
3006 push_decl_namespace (tree decl
)
3008 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3009 decl
= decl_namespace_context (decl
);
3010 decl_namespace_list
= tree_cons (ORIGINAL_NAMESPACE (decl
),
3011 NULL_TREE
, decl_namespace_list
);
3014 /* [namespace.memdef]/2 */
3017 pop_decl_namespace (void)
3019 decl_namespace_list
= TREE_CHAIN (decl_namespace_list
);
3022 /* Return the namespace that is the common ancestor
3023 of two given namespaces. */
3026 namespace_ancestor (tree ns1
, tree ns2
)
3028 timevar_push (TV_NAME_LOOKUP
);
3029 if (is_ancestor (ns1
, ns2
))
3030 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ns1
);
3031 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
3032 namespace_ancestor (CP_DECL_CONTEXT (ns1
), ns2
));
3035 /* Process a namespace-alias declaration. */
3038 do_namespace_alias (tree alias
, tree
namespace)
3040 if (TREE_CODE (namespace) != NAMESPACE_DECL
)
3042 /* The parser did not find it, so it's not there. */
3043 error ("unknown namespace %qD", namespace);
3047 namespace = ORIGINAL_NAMESPACE (namespace);
3049 /* Build the alias. */
3050 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3051 DECL_NAMESPACE_ALIAS (alias
) = namespace;
3052 DECL_EXTERNAL (alias
) = 1;
3053 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3056 /* Emit debug info for namespace alias. */
3057 (*debug_hooks
->global_decl
) (alias
);
3060 /* Like pushdecl, only it places X in the current namespace,
3064 pushdecl_namespace_level (tree x
)
3066 struct cp_binding_level
*b
= current_binding_level
;
3069 timevar_push (TV_NAME_LOOKUP
);
3070 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
3072 /* Now, the type_shadowed stack may screw us. Munge it so it does
3074 if (TREE_CODE (t
) == TYPE_DECL
)
3076 tree name
= DECL_NAME (t
);
3078 tree
*ptr
= (tree
*)0;
3079 for (; !global_scope_p (b
); b
= b
->level_chain
)
3081 tree shadowed
= b
->type_shadowed
;
3082 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3083 if (TREE_PURPOSE (shadowed
) == name
)
3085 ptr
= &TREE_VALUE (shadowed
);
3086 /* Can't break out of the loop here because sometimes
3087 a binding level will have duplicate bindings for
3088 PT names. It's gross, but I haven't time to fix it. */
3091 newval
= TREE_TYPE (t
);
3092 if (ptr
== (tree
*)0)
3094 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3095 up here if this is changed to an assertion. --KR */
3096 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3103 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3106 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3107 directive is not directly from the source. Also find the common
3108 ancestor and let our users know about the new namespace */
3110 add_using_namespace (tree user
, tree used
, bool indirect
)
3113 timevar_push (TV_NAME_LOOKUP
);
3114 /* Using oneself is a no-op. */
3117 timevar_pop (TV_NAME_LOOKUP
);
3120 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3121 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3122 /* Check if we already have this. */
3123 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3127 /* Promote to direct usage. */
3128 TREE_INDIRECT_USING (t
) = 0;
3129 timevar_pop (TV_NAME_LOOKUP
);
3133 /* Add used to the user's using list. */
3134 DECL_NAMESPACE_USING (user
)
3135 = tree_cons (used
, namespace_ancestor (user
, used
),
3136 DECL_NAMESPACE_USING (user
));
3138 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3140 /* Add user to the used's users list. */
3141 DECL_NAMESPACE_USERS (used
)
3142 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3144 /* Recursively add all namespaces used. */
3145 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3146 /* indirect usage */
3147 add_using_namespace (user
, TREE_PURPOSE (t
), 1);
3149 /* Tell everyone using us about the new used namespaces. */
3150 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3151 add_using_namespace (TREE_PURPOSE (t
), used
, 1);
3152 timevar_pop (TV_NAME_LOOKUP
);
3155 /* Process a using-declaration not appearing in class or local scope. */
3158 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3160 tree oldval
, oldtype
, newval
, newtype
;
3161 tree orig_decl
= decl
;
3162 cxx_binding
*binding
;
3164 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3165 if (decl
== NULL_TREE
)
3168 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3170 oldval
= binding
->value
;
3171 oldtype
= binding
->type
;
3173 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3175 /* Emit debug info. */
3176 if (!processing_template_decl
)
3177 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3179 /* Copy declarations found. */
3181 binding
->value
= newval
;
3183 binding
->type
= newtype
;
3187 /* Process a using-directive. */
3190 do_using_directive (tree
namespace)
3192 tree context
= NULL_TREE
;
3194 if (building_stmt_tree ())
3195 add_stmt (build_stmt (USING_STMT
, namespace));
3197 /* using namespace A::B::C; */
3198 if (TREE_CODE (namespace) == SCOPE_REF
)
3199 namespace = TREE_OPERAND (namespace, 1);
3200 if (TREE_CODE (namespace) == IDENTIFIER_NODE
)
3202 /* Lookup in lexer did not find a namespace. */
3203 if (!processing_template_decl
)
3204 error ("namespace %qT undeclared", namespace);
3207 if (TREE_CODE (namespace) != NAMESPACE_DECL
)
3209 if (!processing_template_decl
)
3210 error ("%qT is not a namespace", namespace);
3213 namespace = ORIGINAL_NAMESPACE (namespace);
3214 if (!toplevel_bindings_p ())
3216 push_using_directive (namespace);
3217 context
= current_scope ();
3222 add_using_namespace (current_namespace
, namespace, 0);
3223 if (current_namespace
!= global_namespace
)
3224 context
= current_namespace
;
3227 /* Emit debugging info. */
3228 if (!processing_template_decl
)
3229 (*debug_hooks
->imported_module_or_decl
) (namespace, context
);
3232 /* Deal with a using-directive seen by the parser. Currently we only
3233 handle attributes here, since they cannot appear inside a template. */
3236 parse_using_directive (tree
namespace, tree attribs
)
3240 do_using_directive (namespace);
3242 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3244 tree name
= TREE_PURPOSE (a
);
3245 if (is_attribute_p ("strong", name
))
3247 if (!toplevel_bindings_p ())
3248 error ("strong using only meaningful at namespace scope");
3249 else if (namespace != error_mark_node
)
3250 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3251 = tree_cons (current_namespace
, 0,
3252 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3255 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3259 /* Like pushdecl, only it places X in the global scope if appropriate.
3260 Calls cp_finish_decl to register the variable, initializing it with
3261 *INIT, if INIT is non-NULL. */
3264 pushdecl_top_level_1 (tree x
, tree
*init
)
3266 timevar_push (TV_NAME_LOOKUP
);
3267 push_to_top_level ();
3268 x
= pushdecl_namespace_level (x
);
3270 cp_finish_decl (x
, *init
, NULL_TREE
, 0);
3271 pop_from_top_level ();
3272 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
3275 /* Like pushdecl, only it places X in the global scope if appropriate. */
3278 pushdecl_top_level (tree x
)
3280 return pushdecl_top_level_1 (x
, NULL
);
3283 /* Like pushdecl, only it places X in the global scope if
3284 appropriate. Calls cp_finish_decl to register the variable,
3285 initializing it with INIT. */
3288 pushdecl_top_level_and_finish (tree x
, tree init
)
3290 return pushdecl_top_level_1 (x
, &init
);
3293 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3294 duplicates. The first list becomes the tail of the result.
3296 The algorithm is O(n^2). We could get this down to O(n log n) by
3297 doing a sort on the addresses of the functions, if that becomes
3301 merge_functions (tree s1
, tree s2
)
3303 for (; s2
; s2
= OVL_NEXT (s2
))
3305 tree fn2
= OVL_CURRENT (s2
);
3308 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3310 tree fn1
= OVL_CURRENT (fns1
);
3312 /* If the function from S2 is already in S1, there is no
3313 need to add it again. For `extern "C"' functions, we
3314 might have two FUNCTION_DECLs for the same function, in
3315 different namespaces; again, we only need one of them. */
3317 || (DECL_EXTERN_C_P (fn1
) && DECL_EXTERN_C_P (fn2
)
3318 && DECL_NAME (fn1
) == DECL_NAME (fn2
)))
3322 /* If we exhausted all of the functions in S1, FN2 is new. */
3324 s1
= build_overload (fn2
, s1
);
3329 /* This should return an error not all definitions define functions.
3330 It is not an error if we find two functions with exactly the
3331 same signature, only if these are selected in overload resolution.
3332 old is the current set of bindings, new the freshly-found binding.
3333 XXX Do we want to give *all* candidates in case of ambiguity?
3334 XXX In what way should I treat extern declarations?
3335 XXX I don't want to repeat the entire duplicate_decls here */
3338 ambiguous_decl (tree name
, struct scope_binding
*old
, cxx_binding
*new,
3342 gcc_assert (old
!= NULL
);
3343 /* Copy the value. */
3346 switch (TREE_CODE (val
))
3349 /* If we expect types or namespaces, and not templates,
3350 or this is not a template class. */
3351 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3352 && !DECL_CLASS_TEMPLATE_P (val
))
3353 || hidden_name_p (val
))
3357 if (LOOKUP_NAMESPACES_ONLY (flags
) || hidden_name_p (val
))
3360 case NAMESPACE_DECL
:
3361 if (LOOKUP_TYPES_ONLY (flags
))
3365 /* Ignore built-in functions that are still anticipated. */
3366 if (LOOKUP_QUALIFIERS_ONLY (flags
) || hidden_name_p (val
))
3370 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3376 else if (val
&& val
!= old
->value
)
3378 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3379 old
->value
= merge_functions (old
->value
, val
);
3382 /* Some declarations are functions, some are not. */
3383 if (flags
& LOOKUP_COMPLAIN
)
3385 /* If we've already given this error for this lookup,
3386 old->value is error_mark_node, so let's not
3387 repeat ourselves. */
3388 if (old
->value
!= error_mark_node
)
3390 error ("use of %qD is ambiguous", name
);
3391 error (" first declared as %q+#D here", old
->value
);
3393 error (" also declared as %q+#D here", val
);
3395 old
->value
= error_mark_node
;
3398 /* ... and copy the type. */
3400 if (LOOKUP_NAMESPACES_ONLY (flags
))
3404 else if (type
&& old
->type
!= type
)
3406 if (flags
& LOOKUP_COMPLAIN
)
3408 error ("%qD denotes an ambiguous type",name
);
3409 error ("%J first type here", TYPE_MAIN_DECL (old
->type
));
3410 error ("%J other type here", TYPE_MAIN_DECL (type
));
3415 /* Return the declarations that are members of the namespace NS. */
3418 cp_namespace_decls (tree ns
)
3420 return NAMESPACE_LEVEL (ns
)->names
;
3423 /* Combine prefer_type and namespaces_only into flags. */
3426 lookup_flags (int prefer_type
, int namespaces_only
)
3428 if (namespaces_only
)
3429 return LOOKUP_PREFER_NAMESPACES
;
3430 if (prefer_type
> 1)
3431 return LOOKUP_PREFER_TYPES
;
3432 if (prefer_type
> 0)
3433 return LOOKUP_PREFER_BOTH
;
3437 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3438 ignore it or not. Subroutine of lookup_name_real and
3439 lookup_type_scope. */
3442 qualify_lookup (tree val
, int flags
)
3444 if (val
== NULL_TREE
)
3446 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3448 if ((flags
& LOOKUP_PREFER_TYPES
)
3449 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3451 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
3456 /* Given a lookup that returned VAL, decide if we want to ignore it or
3457 not based on DECL_ANTICIPATED_P. */
3460 hidden_name_p (tree val
)
3463 && DECL_LANG_SPECIFIC (val
)
3464 && DECL_ANTICIPATED (val
))
3469 /* Look up NAME in the NAMESPACE. */
3472 lookup_namespace_name (tree
namespace, tree name
)
3475 tree template_id
= NULL_TREE
;
3476 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3478 timevar_push (TV_NAME_LOOKUP
);
3479 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL
);
3481 if (TREE_CODE (name
) == NAMESPACE_DECL
)
3482 /* This happens for A::B<int> when B is a namespace. */
3483 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, name
);
3484 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
3486 /* This happens for A::B where B is a template, and there are no
3487 template arguments. */
3488 error ("invalid use of %qD", name
);
3489 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3492 namespace = ORIGINAL_NAMESPACE (namespace);
3494 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3497 name
= TREE_OPERAND (name
, 0);
3498 if (TREE_CODE (name
) == OVERLOAD
)
3499 name
= DECL_NAME (OVL_CURRENT (name
));
3500 else if (DECL_P (name
))
3501 name
= DECL_NAME (name
);
3504 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
3506 if (!qualified_lookup_using_namespace (name
, namespace, &binding
, 0))
3507 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3511 val
= binding
.value
;
3515 if (DECL_CLASS_TEMPLATE_P (val
))
3516 val
= lookup_template_class (val
,
3517 TREE_OPERAND (template_id
, 1),
3518 /*in_decl=*/NULL_TREE
,
3519 /*context=*/NULL_TREE
,
3520 /*entering_scope=*/0,
3521 tf_error
| tf_warning
);
3522 else if (DECL_FUNCTION_TEMPLATE_P (val
)
3523 || TREE_CODE (val
) == OVERLOAD
)
3524 val
= lookup_template_function (val
,
3525 TREE_OPERAND (template_id
, 1));
3528 error ("%<%D::%D%> is not a template", namespace, name
);
3529 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3533 /* If we have a single function from a using decl, pull it out. */
3534 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
3535 val
= OVL_FUNCTION (val
);
3537 /* Ignore built-in functions and friends that haven't been declared
3539 if (!val
|| !hidden_name_p (val
))
3540 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3543 error ("%qD undeclared in namespace %qD", name
, namespace);
3544 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3547 /* Select the right _DECL from multiple choices. */
3550 select_decl (const struct scope_binding
*binding
, int flags
)
3553 val
= binding
->value
;
3555 timevar_push (TV_NAME_LOOKUP
);
3556 if (LOOKUP_NAMESPACES_ONLY (flags
))
3558 /* We are not interested in types. */
3559 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
3560 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3561 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3564 /* If looking for a type, or if there is no non-type binding, select
3565 the value binding. */
3566 if (binding
->type
&& (!val
|| (flags
& LOOKUP_PREFER_TYPES
)))
3567 val
= binding
->type
;
3568 /* Don't return non-types if we really prefer types. */
3569 else if (val
&& LOOKUP_TYPES_ONLY (flags
)
3570 && ! DECL_DECLARES_TYPE_P (val
))
3573 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3576 /* Unscoped lookup of a global: iterate over current namespaces,
3577 considering using-directives. */
3580 unqualified_namespace_lookup (tree name
, int flags
)
3582 tree initial
= current_decl_namespace ();
3583 tree scope
= initial
;
3585 struct cp_binding_level
*level
;
3586 tree val
= NULL_TREE
;
3587 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3589 timevar_push (TV_NAME_LOOKUP
);
3591 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
3594 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3598 if (b
->value
&& hidden_name_p (b
->value
))
3599 /* Ignore anticipated built-in functions and friends. */
3602 binding
.value
= b
->value
;
3603 binding
.type
= b
->type
;
3606 /* Add all _DECLs seen through local using-directives. */
3607 for (level
= current_binding_level
;
3608 level
->kind
!= sk_namespace
;
3609 level
= level
->level_chain
)
3610 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
3612 /* Give up because of error. */
3613 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3615 /* Add all _DECLs seen through global using-directives. */
3616 /* XXX local and global using lists should work equally. */
3620 if (!lookup_using_namespace (name
, &binding
,
3621 DECL_NAMESPACE_USING (siter
),
3623 /* Give up because of error. */
3624 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3625 if (siter
== scope
) break;
3626 siter
= CP_DECL_CONTEXT (siter
);
3629 val
= select_decl (&binding
, flags
);
3630 if (scope
== global_namespace
)
3633 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3636 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3637 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3640 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3641 declaration found. If no suitable declaration can be found,
3642 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3643 neither a class-type nor a namespace a diagnostic is issued. */
3646 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
3650 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3652 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3654 flags
|= LOOKUP_COMPLAIN
;
3656 flags
|= LOOKUP_PREFER_TYPES
;
3657 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
3658 return select_decl (&binding
, flags
);
3660 else if (is_aggr_type (scope
, complain
))
3663 t
= lookup_member (scope
, name
, 2, is_type_p
);
3668 return error_mark_node
;
3671 /* Subroutine of unqualified_namespace_lookup:
3672 Add the bindings of NAME in used namespaces to VAL.
3673 We are currently looking for names in namespace SCOPE, so we
3674 look through USINGS for using-directives of namespaces
3675 which have SCOPE as a common ancestor with the current scope.
3676 Returns false on errors. */
3679 lookup_using_namespace (tree name
, struct scope_binding
*val
,
3680 tree usings
, tree scope
, int flags
)
3683 timevar_push (TV_NAME_LOOKUP
);
3684 /* Iterate over all used namespaces in current, searching for using
3685 directives of scope. */
3686 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
3687 if (TREE_VALUE (iter
) == scope
)
3689 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
3691 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
3692 /* Resolve ambiguities. */
3694 ambiguous_decl (name
, val
, val1
, flags
);
3696 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
->value
!= error_mark_node
);
3700 Accepts the NAME to lookup and its qualifying SCOPE.
3701 Returns the name/type pair found into the cxx_binding *RESULT,
3702 or false on error. */
3705 qualified_lookup_using_namespace (tree name
, tree scope
,
3706 struct scope_binding
*result
, int flags
)
3708 /* Maintain a list of namespaces visited... */
3709 tree seen
= NULL_TREE
;
3710 /* ... and a list of namespace yet to see. */
3711 tree todo
= NULL_TREE
;
3712 tree todo_maybe
= NULL_TREE
;
3714 timevar_push (TV_NAME_LOOKUP
);
3715 /* Look through namespace aliases. */
3716 scope
= ORIGINAL_NAMESPACE (scope
);
3717 while (scope
&& result
->value
!= error_mark_node
)
3719 cxx_binding
*binding
=
3720 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3721 seen
= tree_cons (scope
, NULL_TREE
, seen
);
3723 ambiguous_decl (name
, result
, binding
, flags
);
3725 /* Consider strong using directives always, and non-strong ones
3726 if we haven't found a binding yet. ??? Shouldn't we consider
3727 non-strong ones if the initial RESULT is non-NULL, but the
3728 binding in the given namespace is? */
3729 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
3730 usings
= TREE_CHAIN (usings
))
3731 /* If this was a real directive, and we have not seen it. */
3732 if (!TREE_INDIRECT_USING (usings
))
3734 /* Try to avoid queuing the same namespace more than once,
3735 the exception being when a namespace was already
3736 enqueued for todo_maybe and then a strong using is
3737 found for it. We could try to remove it from
3738 todo_maybe, but it's probably not worth the effort. */
3739 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
))
3740 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3741 && !purpose_member (TREE_PURPOSE (usings
), todo
))
3742 todo
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
, todo
);
3743 else if ((!result
->value
&& !result
->type
)
3744 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3745 && !purpose_member (TREE_PURPOSE (usings
), todo
)
3746 && !purpose_member (TREE_PURPOSE (usings
), todo_maybe
))
3747 todo_maybe
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
,
3752 scope
= TREE_PURPOSE (todo
);
3753 todo
= TREE_CHAIN (todo
);
3756 && (!result
->value
&& !result
->type
))
3758 scope
= TREE_PURPOSE (todo_maybe
);
3759 todo
= TREE_CHAIN (todo_maybe
);
3760 todo_maybe
= NULL_TREE
;
3763 scope
= NULL_TREE
; /* If there never was a todo list. */
3765 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
->value
!= error_mark_node
);
3768 /* Return the innermost non-namespace binding for NAME from a scope
3769 containing BINDING, or, if BINDING is NULL, the current scope. If
3770 CLASS_P is false, then class bindings are ignored. */
3773 outer_binding (tree name
,
3774 cxx_binding
*binding
,
3779 cxx_scope
*outer_scope
;
3783 scope
= binding
->scope
->level_chain
;
3784 outer
= binding
->previous
;
3788 scope
= current_binding_level
;
3789 outer
= IDENTIFIER_BINDING (name
);
3791 outer_scope
= outer
? outer
->scope
: NULL
;
3793 /* Because we create class bindings lazily, we might be missing a
3794 class binding for NAME. If there are any class binding levels
3795 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3796 declared, we must lookup NAME in those class scopes. */
3798 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
3800 if (scope
->kind
== sk_class
)
3802 cxx_binding
*class_binding
;
3804 class_binding
= get_class_binding (name
, scope
);
3807 /* Thread this new class-scope binding onto the
3808 IDENTIFIER_BINDING list so that future lookups
3810 class_binding
->previous
= outer
;
3812 binding
->previous
= class_binding
;
3814 IDENTIFIER_BINDING (name
) = class_binding
;
3815 return class_binding
;
3818 scope
= scope
->level_chain
;
3824 /* Return the innermost block-scope or class-scope value binding for
3825 NAME, or NULL_TREE if there is no such binding. */
3828 innermost_non_namespace_value (tree name
)
3830 cxx_binding
*binding
;
3831 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
3832 return binding
? binding
->value
: NULL_TREE
;
3835 /* Look up NAME in the current binding level and its superiors in the
3836 namespace of variables, functions and typedefs. Return a ..._DECL
3837 node of some kind representing its definition if there is only one
3838 such declaration, or return a TREE_LIST with all the overloaded
3839 definitions if there are many, or return 0 if it is undefined.
3840 Hidden name, either friend declaration or built-in function, are
3843 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3844 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3845 Otherwise we prefer non-TYPE_DECLs.
3847 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3848 BLOCK_P is false, bindings in block scopes are ignored. */
3851 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
3852 int namespaces_only
, int flags
)
3855 tree val
= NULL_TREE
;
3857 timevar_push (TV_NAME_LOOKUP
);
3858 /* Conversion operators are handled specially because ordinary
3859 unqualified name lookup will not find template conversion
3861 if (IDENTIFIER_TYPENAME_P (name
))
3863 struct cp_binding_level
*level
;
3865 for (level
= current_binding_level
;
3866 level
&& level
->kind
!= sk_namespace
;
3867 level
= level
->level_chain
)
3872 /* A conversion operator can only be declared in a class
3874 if (level
->kind
!= sk_class
)
3877 /* Lookup the conversion operator in the class. */
3878 class_type
= level
->this_entity
;
3879 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
3881 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, operators
);
3884 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3887 flags
|= lookup_flags (prefer_type
, namespaces_only
);
3889 /* First, look in non-namespace scopes. */
3891 if (current_class_type
== NULL_TREE
)
3894 if (block_p
|| !nonclass
)
3895 for (iter
= outer_binding (name
, NULL
, !nonclass
);
3897 iter
= outer_binding (name
, iter
, !nonclass
))
3901 /* Skip entities we don't want. */
3902 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
3905 /* If this is the kind of thing we're looking for, we're done. */
3906 if (qualify_lookup (iter
->value
, flags
)
3907 && !hidden_name_p (iter
->value
))
3908 binding
= iter
->value
;
3909 else if ((flags
& LOOKUP_PREFER_TYPES
)
3910 && qualify_lookup (iter
->type
, flags
)
3911 && !hidden_name_p (iter
->type
))
3912 binding
= iter
->type
;
3914 binding
= NULL_TREE
;
3923 /* Now lookup in namespace scopes. */
3925 val
= unqualified_namespace_lookup (name
, flags
);
3929 /* If we have a single function from a using decl, pull it out. */
3930 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
3931 val
= OVL_FUNCTION (val
);
3934 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3938 lookup_name_nonclass (tree name
)
3940 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
3944 lookup_function_nonclass (tree name
, tree args
, bool block_p
)
3947 lookup_arg_dependent (name
,
3948 lookup_name_real (name
, 0, 1, block_p
, 0,
3954 lookup_name (tree name
, int prefer_type
)
3956 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
3957 0, LOOKUP_COMPLAIN
);
3960 /* Look up NAME for type used in elaborated name specifier in
3961 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
3962 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
3963 name, more scopes are checked if cleanup or template parameter
3964 scope is encountered.
3966 Unlike lookup_name_real, we make sure that NAME is actually
3967 declared in the desired scope, not from inheritance, nor using
3968 directive. For using declaration, there is DR138 still waiting
3969 to be resolved. Hidden name coming from an earlier friend
3970 declaration is also returned.
3972 A TYPE_DECL best matching the NAME is returned. Catching error
3973 and issuing diagnostics are caller's responsibility. */
3976 lookup_type_scope (tree name
, tag_scope scope
)
3978 cxx_binding
*iter
= NULL
;
3979 tree val
= NULL_TREE
;
3981 timevar_push (TV_NAME_LOOKUP
);
3983 /* Look in non-namespace scope first. */
3984 if (current_binding_level
->kind
!= sk_namespace
)
3985 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
3986 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
3988 /* Check if this is the kind of thing we're looking for.
3989 If SCOPE is TS_CURRENT, also make sure it doesn't come from
3990 base class. For ITER->VALUE, we can simply use
3991 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
3994 We check ITER->TYPE before ITER->VALUE in order to handle
3995 typedef struct C {} C;
3998 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
3999 && (scope
!= ts_current
4000 || LOCAL_BINDING_P (iter
)
4001 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4003 else if ((scope
!= ts_current
4004 || !INHERITED_VALUE_BINDING_P (iter
))
4005 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4012 /* Look in namespace scope. */
4015 iter
= cxx_scope_find_binding_for_name
4016 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4020 /* If this is the kind of thing we're looking for, we're done. */
4021 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4023 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4029 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4030 and template parameter scopes. */
4033 struct cp_binding_level
*b
= current_binding_level
;
4036 if (iter
->scope
== b
)
4037 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4039 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
)
4041 else if (b
->kind
== sk_class
4042 && scope
== ts_within_enclosing_non_class
)
4049 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4052 /* Similar to `lookup_name' but look only in the innermost non-class
4056 lookup_name_innermost_nonclass_level (tree name
)
4058 struct cp_binding_level
*b
;
4061 timevar_push (TV_NAME_LOOKUP
);
4062 b
= innermost_nonclass_level ();
4064 if (b
->kind
== sk_namespace
)
4066 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4068 /* extern "C" function() */
4069 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4072 else if (IDENTIFIER_BINDING (name
)
4073 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4075 cxx_binding
*binding
;
4076 binding
= IDENTIFIER_BINDING (name
);
4079 if (binding
->scope
== b
4080 && !(TREE_CODE (binding
->value
) == VAR_DECL
4081 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4082 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
->value
);
4084 if (b
->kind
== sk_cleanup
)
4091 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4094 /* Like lookup_name_innermost_nonclass_level, but for types. */
4097 lookup_type_current_level (tree name
)
4101 timevar_push (TV_NAME_LOOKUP
);
4102 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4104 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4105 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4107 struct cp_binding_level
*b
= current_binding_level
;
4110 if (purpose_member (name
, b
->type_shadowed
))
4111 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
4112 REAL_IDENTIFIER_TYPE_VALUE (name
));
4113 if (b
->kind
== sk_cleanup
)
4120 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4123 /* [basic.lookup.koenig] */
4124 /* A nonzero return value in the functions below indicates an error. */
4134 static bool arg_assoc (struct arg_lookup
*, tree
);
4135 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4136 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4137 static bool add_function (struct arg_lookup
*, tree
);
4138 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4139 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4140 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4142 /* Add a function to the lookup structure.
4143 Returns true on error. */
4146 add_function (struct arg_lookup
*k
, tree fn
)
4148 /* We used to check here to see if the function was already in the list,
4149 but that's O(n^2), which is just too expensive for function lookup.
4150 Now we deal with the occasional duplicate in joust. In doing this, we
4151 assume that the number of duplicates will be small compared to the
4152 total number of functions being compared, which should usually be the
4155 /* We must find only functions, or exactly one non-function. */
4158 else if (fn
== k
->functions
)
4160 else if (is_overloaded_fn (k
->functions
) && is_overloaded_fn (fn
))
4161 k
->functions
= build_overload (fn
, k
->functions
);
4164 tree f1
= OVL_CURRENT (k
->functions
);
4166 if (is_overloaded_fn (f1
))
4168 fn
= f1
; f1
= f2
; f2
= fn
;
4170 error ("%q+D is not a function,", f1
);
4171 error (" conflict with %q+D", f2
);
4172 error (" in call to %qD", k
->name
);
4179 /* Returns true iff CURRENT has declared itself to be an associated
4180 namespace of SCOPE via a strong using-directive (or transitive chain
4181 thereof). Both are namespaces. */
4184 is_associated_namespace (tree current
, tree scope
)
4186 tree seen
= NULL_TREE
;
4187 tree todo
= NULL_TREE
;
4191 if (scope
== current
)
4193 seen
= tree_cons (scope
, NULL_TREE
, seen
);
4194 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4195 if (!purpose_member (TREE_PURPOSE (t
), seen
))
4196 todo
= tree_cons (TREE_PURPOSE (t
), NULL_TREE
, todo
);
4199 scope
= TREE_PURPOSE (todo
);
4200 todo
= TREE_CHAIN (todo
);
4207 /* Add functions of a namespace to the lookup structure.
4208 Returns true on error. */
4211 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4215 if (purpose_member (scope
, k
->namespaces
))
4217 k
->namespaces
= tree_cons (scope
, NULL_TREE
, k
->namespaces
);
4219 /* Check out our super-users. */
4220 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4221 value
= TREE_CHAIN (value
))
4222 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4225 value
= namespace_binding (k
->name
, scope
);
4229 for (; value
; value
= OVL_NEXT (value
))
4230 if (add_function (k
, OVL_CURRENT (value
)))
4236 /* Adds everything associated with a template argument to the lookup
4237 structure. Returns true on error. */
4240 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4242 /* [basic.lookup.koenig]
4244 If T is a template-id, its associated namespaces and classes are
4245 ... the namespaces and classes associated with the types of the
4246 template arguments provided for template type parameters
4247 (excluding template template parameters); the namespaces in which
4248 any template template arguments are defined; and the classes in
4249 which any member templates used as template template arguments
4250 are defined. [Note: non-type template arguments do not
4251 contribute to the set of associated namespaces. ] */
4253 /* Consider first template template arguments. */
4254 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4255 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
4257 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
4259 tree ctx
= CP_DECL_CONTEXT (arg
);
4261 /* It's not a member template. */
4262 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4263 return arg_assoc_namespace (k
, ctx
);
4264 /* Otherwise, it must be member template. */
4266 return arg_assoc_class (k
, ctx
);
4268 /* It's not a template template argument, but it is a type template
4270 else if (TYPE_P (arg
))
4271 return arg_assoc_type (k
, arg
);
4272 /* It's a non-type template argument. */
4277 /* Adds everything associated with class to the lookup structure.
4278 Returns true on error. */
4281 arg_assoc_class (struct arg_lookup
*k
, tree type
)
4283 tree list
, friends
, context
;
4286 /* Backend build structures, such as __builtin_va_list, aren't
4287 affected by all this. */
4288 if (!CLASS_TYPE_P (type
))
4291 if (purpose_member (type
, k
->classes
))
4293 k
->classes
= tree_cons (type
, NULL_TREE
, k
->classes
);
4295 context
= decl_namespace_context (type
);
4296 if (arg_assoc_namespace (k
, context
))
4299 if (TYPE_BINFO (type
))
4301 /* Process baseclasses. */
4302 tree binfo
, base_binfo
;
4304 for (binfo
= TYPE_BINFO (type
), i
= 0;
4305 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4306 if (arg_assoc_class (k
, BINFO_TYPE (base_binfo
)))
4310 /* Process friends. */
4311 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
4312 list
= TREE_CHAIN (list
))
4313 if (k
->name
== FRIEND_NAME (list
))
4314 for (friends
= FRIEND_DECLS (list
); friends
;
4315 friends
= TREE_CHAIN (friends
))
4317 tree fn
= TREE_VALUE (friends
);
4319 /* Only interested in global functions with potentially hidden
4320 (i.e. unqualified) declarations. */
4321 if (CP_DECL_CONTEXT (fn
) != context
)
4323 /* Template specializations are never found by name lookup.
4324 (Templates themselves can be found, but not template
4325 specializations.) */
4326 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
4328 if (add_function (k
, fn
))
4332 /* Process template arguments. */
4333 if (CLASSTYPE_TEMPLATE_INFO (type
)
4334 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
4336 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
4337 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
4338 arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
));
4344 /* Adds everything associated with a given type.
4345 Returns 1 on error. */
4348 arg_assoc_type (struct arg_lookup
*k
, tree type
)
4350 /* As we do not get the type of non-type dependent expressions
4351 right, we can end up with such things without a type. */
4355 if (TYPE_PTRMEM_P (type
))
4357 /* Pointer to member: associate class type and value type. */
4358 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
4360 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
4362 else switch (TREE_CODE (type
))
4375 if (TYPE_PTRMEMFUNC_P (type
))
4376 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
4377 return arg_assoc_class (k
, type
);
4379 case REFERENCE_TYPE
:
4381 return arg_assoc_type (k
, TREE_TYPE (type
));
4384 return arg_assoc_namespace (k
, decl_namespace_context (type
));
4386 /* The basetype is referenced in the first arg type, so just
4389 /* Associate the parameter types. */
4390 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
4392 /* Associate the return type. */
4393 return arg_assoc_type (k
, TREE_TYPE (type
));
4394 case TEMPLATE_TYPE_PARM
:
4395 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4400 gcc_assert (type
== unknown_type_node
);
4408 /* Adds everything associated with arguments. Returns true on error. */
4411 arg_assoc_args (struct arg_lookup
*k
, tree args
)
4413 for (; args
; args
= TREE_CHAIN (args
))
4414 if (arg_assoc (k
, TREE_VALUE (args
)))
4419 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4422 arg_assoc (struct arg_lookup
*k
, tree n
)
4424 if (n
== error_mark_node
)
4428 return arg_assoc_type (k
, n
);
4430 if (! type_unknown_p (n
))
4431 return arg_assoc_type (k
, TREE_TYPE (n
));
4433 if (TREE_CODE (n
) == ADDR_EXPR
)
4434 n
= TREE_OPERAND (n
, 0);
4435 if (TREE_CODE (n
) == COMPONENT_REF
)
4436 n
= TREE_OPERAND (n
, 1);
4437 if (TREE_CODE (n
) == OFFSET_REF
)
4438 n
= TREE_OPERAND (n
, 1);
4439 while (TREE_CODE (n
) == TREE_LIST
)
4441 if (TREE_CODE (n
) == BASELINK
)
4442 n
= BASELINK_FUNCTIONS (n
);
4444 if (TREE_CODE (n
) == FUNCTION_DECL
)
4445 return arg_assoc_type (k
, TREE_TYPE (n
));
4446 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
4448 /* [basic.lookup.koenig]
4450 If T is a template-id, its associated namespaces and classes
4451 are the namespace in which the template is defined; for
4452 member templates, the member template's class... */
4453 tree
template = TREE_OPERAND (n
, 0);
4454 tree args
= TREE_OPERAND (n
, 1);
4458 if (TREE_CODE (template) == COMPONENT_REF
)
4459 template = TREE_OPERAND (template, 1);
4461 /* First, the template. There may actually be more than one if
4462 this is an overloaded function template. But, in that case,
4463 we only need the first; all the functions will be in the same
4465 template = OVL_CURRENT (template);
4467 ctx
= CP_DECL_CONTEXT (template);
4469 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4471 if (arg_assoc_namespace (k
, ctx
) == 1)
4474 /* It must be a member template. */
4475 else if (arg_assoc_class (k
, ctx
) == 1)
4478 /* Now the arguments. */
4479 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
4480 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
4483 else if (TREE_CODE (n
) == OVERLOAD
)
4485 for (; n
; n
= OVL_CHAIN (n
))
4486 if (arg_assoc_type (k
, TREE_TYPE (OVL_FUNCTION (n
))))
4493 /* Performs Koenig lookup depending on arguments, where fns
4494 are the functions found in normal lookup. */
4497 lookup_arg_dependent (tree name
, tree fns
, tree args
)
4499 struct arg_lookup k
;
4501 timevar_push (TV_NAME_LOOKUP
);
4504 k
.classes
= NULL_TREE
;
4506 /* We previously performed an optimization here by setting
4507 NAMESPACES to the current namespace when it was safe. However, DR
4508 164 says that namespaces that were already searched in the first
4509 stage of template processing are searched again (potentially
4510 picking up later definitions) in the second stage. */
4511 k
.namespaces
= NULL_TREE
;
4513 arg_assoc_args (&k
, args
);
4514 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, k
.functions
);
4517 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4518 changed (i.e. there was already a directive), or the fresh
4519 TREE_LIST otherwise. */
4522 push_using_directive (tree used
)
4524 tree ud
= current_binding_level
->using_directives
;
4525 tree iter
, ancestor
;
4527 timevar_push (TV_NAME_LOOKUP
);
4528 /* Check if we already have this. */
4529 if (purpose_member (used
, ud
) != NULL_TREE
)
4530 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4532 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4533 ud
= current_binding_level
->using_directives
;
4534 ud
= tree_cons (used
, ancestor
, ud
);
4535 current_binding_level
->using_directives
= ud
;
4537 /* Recursively add all namespaces used. */
4538 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4539 push_using_directive (TREE_PURPOSE (iter
));
4541 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ud
);
4544 /* The type TYPE is being declared. If it is a class template, or a
4545 specialization of a class template, do any processing required and
4546 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4547 being declared a friend. B is the binding level at which this TYPE
4550 Returns the TYPE_DECL for TYPE, which may have been altered by this
4554 maybe_process_template_type_declaration (tree type
, int is_friend
,
4557 tree decl
= TYPE_NAME (type
);
4559 if (processing_template_parmlist
)
4560 /* You can't declare a new template type in a template parameter
4561 list. But, you can declare a non-template type:
4563 template <class A*> struct S;
4565 is a forward-declaration of `A'. */
4569 gcc_assert (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ENUMERAL_TYPE
);
4571 if (processing_template_decl
)
4573 /* This may change after the call to
4574 push_template_decl_real, but we want the original value. */
4575 tree name
= DECL_NAME (decl
);
4577 decl
= push_template_decl_real (decl
, is_friend
);
4578 /* If the current binding level is the binding level for the
4579 template parameters (see the comment in
4580 begin_template_parm_list) and the enclosing level is a class
4581 scope, and we're not looking at a friend, push the
4582 declaration of the member class into the class scope. In the
4583 friend case, push_template_decl will already have put the
4584 friend into global scope, if appropriate. */
4585 if (TREE_CODE (type
) != ENUMERAL_TYPE
4586 && !is_friend
&& b
->kind
== sk_template_parms
4587 && b
->level_chain
->kind
== sk_class
)
4589 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
4591 if (!COMPLETE_TYPE_P (current_class_type
))
4593 maybe_add_class_template_decl_list (current_class_type
,
4594 type
, /*friend_p=*/0);
4595 /* Put this UTD in the table of UTDs for the class. */
4596 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
4597 CLASSTYPE_NESTED_UTDS (current_class_type
) =
4598 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4600 binding_table_insert
4601 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
4610 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4611 that the NAME is a class template, the tag is processed but not pushed.
4613 The pushed scope depend on the SCOPE parameter:
4614 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4616 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4617 non-template-parameter scope. This case is needed for forward
4619 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4620 TS_GLOBAL case except that names within template-parameter scopes
4621 are not pushed at all.
4623 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4626 pushtag (tree name
, tree type
, tag_scope scope
)
4628 struct cp_binding_level
*b
;
4630 timevar_push (TV_NAME_LOOKUP
);
4631 b
= current_binding_level
;
4632 while (/* Cleanup scopes are not scopes from the point of view of
4634 b
->kind
== sk_cleanup
4635 /* Neither are the scopes used to hold template parameters
4636 for an explicit specialization. For an ordinary template
4637 declaration, these scopes are not scopes from the point of
4638 view of the language. */
4639 || (b
->kind
== sk_template_parms
4640 && (b
->explicit_spec_p
|| scope
== ts_global
))
4641 || (b
->kind
== sk_class
4642 && (scope
!= ts_current
4643 /* We may be defining a new type in the initializer
4644 of a static member variable. We allow this when
4645 not pedantic, and it is particularly useful for
4646 type punning via an anonymous union. */
4647 || COMPLETE_TYPE_P (b
->this_entity
))))
4652 /* Do C++ gratuitous typedefing. */
4653 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
4657 tree context
= TYPE_CONTEXT (type
);
4661 tree cs
= current_scope ();
4663 if (scope
== ts_current
)
4665 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
4666 /* When declaring a friend class of a local class, we want
4667 to inject the newly named class into the scope
4668 containing the local class, not the namespace scope. */
4669 context
= decl_function_context (get_type_decl (cs
));
4672 context
= current_namespace
;
4674 if (b
->kind
== sk_class
4675 || (b
->kind
== sk_template_parms
4676 && b
->level_chain
->kind
== sk_class
))
4679 if (current_lang_name
== lang_name_java
)
4680 TYPE_FOR_JAVA (type
) = 1;
4682 d
= create_implicit_typedef (name
, type
);
4683 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
4684 if (scope
== ts_within_enclosing_non_class
)
4686 /* This is a friend. Make this TYPE_DECL node hidden from
4687 ordinary name lookup. Its corresponding TEMPLATE_DECL
4688 will be marked in push_template_decl_real. */
4689 retrofit_lang_decl (d
);
4690 DECL_ANTICIPATED (d
) = 1;
4691 DECL_FRIEND_P (d
) = 1;
4695 set_identifier_type_value_with_scope (name
, d
, b
);
4697 d
= maybe_process_template_type_declaration
4698 (type
, scope
== ts_within_enclosing_non_class
, b
);
4699 if (d
== error_mark_node
)
4700 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
4702 if (b
->kind
== sk_class
)
4704 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4705 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4706 class. But if it's a member template class, we
4707 want the TEMPLATE_DECL, not the TYPE_DECL, so this
4709 finish_member_declaration (d
);
4711 pushdecl_class_level (d
);
4713 else if (b
->kind
!= sk_template_parms
)
4714 d
= pushdecl_with_scope (d
, b
);
4716 if (d
== error_mark_node
)
4717 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
4719 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
4721 /* If this is a local class, keep track of it. We need this
4722 information for name-mangling, and so that it is possible to find
4723 all function definitions in a translation unit in a convenient
4724 way. (It's otherwise tricky to find a member function definition
4725 it's only pointed to from within a local class.) */
4726 if (TYPE_CONTEXT (type
)
4727 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
4728 VEC_safe_push (tree
, gc
, local_classes
, type
);
4730 if (b
->kind
== sk_class
4731 && !COMPLETE_TYPE_P (current_class_type
))
4733 maybe_add_class_template_decl_list (current_class_type
,
4734 type
, /*friend_p=*/0);
4736 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
4737 CLASSTYPE_NESTED_UTDS (current_class_type
)
4738 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4740 binding_table_insert
4741 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
4745 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
4746 /* Use the canonical TYPE_DECL for this node. */
4747 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
4750 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
4751 will be the tagged type we just added to the current
4752 binding level. This fake NULL-named TYPE_DECL node helps
4753 dwarfout.c to know when it needs to output a
4754 representation of a tagged type, and it also gives us a
4755 convenient place to record the "scope start" address for
4758 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
4759 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
4761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, type
);
4764 /* Subroutines for reverting temporarily to top-level for instantiation
4765 of templates and such. We actually need to clear out the class- and
4766 local-value slots of all identifiers, so that only the global values
4767 are at all visible. Simply setting current_binding_level to the global
4768 scope isn't enough, because more binding levels may be pushed. */
4769 struct saved_scope
*scope_chain
;
4771 /* If ID has not already been marked, add an appropriate binding to
4775 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
4777 cxx_saved_binding
*saved
;
4779 if (!id
|| !IDENTIFIER_BINDING (id
))
4782 if (IDENTIFIER_MARKED (id
))
4785 IDENTIFIER_MARKED (id
) = 1;
4787 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
4788 saved
->identifier
= id
;
4789 saved
->binding
= IDENTIFIER_BINDING (id
);
4790 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
4791 IDENTIFIER_BINDING (id
) = NULL
;
4795 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
4799 timevar_push (TV_NAME_LOOKUP
);
4800 for (t
= names
; t
; t
= TREE_CHAIN (t
))
4804 if (TREE_CODE (t
) == TREE_LIST
)
4805 id
= TREE_PURPOSE (t
);
4809 store_binding (id
, old_bindings
);
4811 timevar_pop (TV_NAME_LOOKUP
);
4814 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4815 objects, rather than a TREE_LIST. */
4818 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
4819 VEC(cxx_saved_binding
,gc
) **old_bindings
)
4822 cp_class_binding
*cb
;
4824 timevar_push (TV_NAME_LOOKUP
);
4825 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
4826 store_binding (cb
->identifier
, old_bindings
);
4827 timevar_pop (TV_NAME_LOOKUP
);
4831 push_to_top_level (void)
4833 struct saved_scope
*s
;
4834 struct cp_binding_level
*b
;
4835 cxx_saved_binding
*sb
;
4839 timevar_push (TV_NAME_LOOKUP
);
4840 s
= GGC_CNEW (struct saved_scope
);
4842 b
= scope_chain
? current_binding_level
: 0;
4844 /* If we're in the middle of some function, save our state. */
4848 push_function_context_to (NULL_TREE
);
4853 if (scope_chain
&& previous_class_level
)
4854 store_class_bindings (previous_class_level
->class_shadowed
,
4857 /* Have to include the global scope, because class-scope decls
4858 aren't listed anywhere useful. */
4859 for (; b
; b
= b
->level_chain
)
4863 /* Template IDs are inserted into the global level. If they were
4864 inserted into namespace level, finish_file wouldn't find them
4865 when doing pending instantiations. Therefore, don't stop at
4866 namespace level, but continue until :: . */
4867 if (global_scope_p (b
))
4870 store_bindings (b
->names
, &s
->old_bindings
);
4871 /* We also need to check class_shadowed to save class-level type
4872 bindings, since pushclass doesn't fill in b->names. */
4873 if (b
->kind
== sk_class
)
4874 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
4876 /* Unwind type-value slots back to top level. */
4877 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
4878 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
4881 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, sb
); ++i
)
4882 IDENTIFIER_MARKED (sb
->identifier
) = 0;
4884 s
->prev
= scope_chain
;
4886 s
->need_pop_function_context
= need_pop
;
4887 s
->function_decl
= current_function_decl
;
4890 current_function_decl
= NULL_TREE
;
4891 current_lang_base
= VEC_alloc (tree
, gc
, 10);
4892 current_lang_name
= lang_name_cplusplus
;
4893 current_namespace
= global_namespace
;
4894 timevar_pop (TV_NAME_LOOKUP
);
4898 pop_from_top_level (void)
4900 struct saved_scope
*s
= scope_chain
;
4901 cxx_saved_binding
*saved
;
4904 timevar_push (TV_NAME_LOOKUP
);
4905 /* Clear out class-level bindings cache. */
4906 if (previous_class_level
)
4907 invalidate_class_lookup_cache ();
4909 current_lang_base
= 0;
4911 scope_chain
= s
->prev
;
4912 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, saved
); ++i
)
4914 tree id
= saved
->identifier
;
4916 IDENTIFIER_BINDING (id
) = saved
->binding
;
4917 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
4920 /* If we were in the middle of compiling a function, restore our
4922 if (s
->need_pop_function_context
)
4923 pop_function_context_from (NULL_TREE
);
4924 current_function_decl
= s
->function_decl
;
4925 timevar_pop (TV_NAME_LOOKUP
);
4928 /* Pop off extraneous binding levels left over due to syntax errors.
4930 We don't pop past namespaces, as they might be valid. */
4933 pop_everything (void)
4935 if (ENABLE_SCOPE_CHECKING
)
4936 verbatim ("XXX entering pop_everything ()\n");
4937 while (!toplevel_bindings_p ())
4939 if (current_binding_level
->kind
== sk_class
)
4940 pop_nested_class ();
4944 if (ENABLE_SCOPE_CHECKING
)
4945 verbatim ("XXX leaving pop_everything ()\n");
4948 /* Emit debugging information for using declarations and directives.
4949 If input tree is overloaded fn then emit debug info for all
4953 cp_emit_debug_info_for_using (tree t
, tree context
)
4955 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
4956 of a builtin function. */
4957 if (TREE_CODE (t
) == FUNCTION_DECL
4958 && DECL_EXTERNAL (t
)
4959 && DECL_BUILT_IN (t
))
4962 /* Do not supply context to imported_module_or_decl, if
4963 it is a global namespace. */
4964 if (context
== global_namespace
)
4965 context
= NULL_TREE
;
4968 t
= BASELINK_FUNCTIONS (t
);
4970 /* FIXME: Handle TEMPLATE_DECLs. */
4971 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
4972 if (TREE_CODE (t
) != TEMPLATE_DECL
)
4973 (*debug_hooks
->imported_module_or_decl
) (t
, context
);
4976 #include "gt-cp-name-lookup.h"