1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
32 #include "diagnostic.h"
36 /* The bindings for a particular name in a particular scope. */
38 struct scope_binding
{
42 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
44 static cxx_scope
*innermost_nonclass_level (void);
45 static tree
select_decl (const struct scope_binding
*, int);
46 static cxx_binding
*binding_for_name (cxx_scope
*, tree
);
47 static tree
lookup_name_innermost_nonclass_level (tree
);
48 static tree
push_overloaded_decl (tree
, int, bool);
49 static bool lookup_using_namespace (tree
, struct scope_binding
*, tree
,
51 static bool qualified_lookup_using_namespace (tree
, tree
,
52 struct scope_binding
*, int);
53 static tree
lookup_type_current_level (tree
);
54 static tree
push_using_directive (tree
);
56 /* The :: namespace. */
58 tree global_namespace
;
60 /* The name of the anonymous namespace, throughout this translation
62 static GTY(()) tree anonymous_namespace_name
;
65 /* Compute the chain index of a binding_entry given the HASH value of its
66 name and the total COUNT of chains. COUNT is assumed to be a power
69 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
71 /* A free list of "binding_entry"s awaiting for re-use. */
73 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
75 /* Create a binding_entry object for (NAME, TYPE). */
77 static inline binding_entry
78 binding_entry_make (tree name
, tree type
)
82 if (free_binding_entry
)
84 entry
= free_binding_entry
;
85 free_binding_entry
= entry
->chain
;
88 entry
= GGC_NEW (struct binding_entry_s
);
97 /* Put ENTRY back on the free list. */
100 binding_entry_free (binding_entry entry
)
104 entry
->chain
= free_binding_entry
;
105 free_binding_entry
= entry
;
109 /* The datatype used to implement the mapping from names to types at
111 struct binding_table_s
GTY(())
113 /* Array of chains of "binding_entry"s */
114 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
116 /* The number of chains in this table. This is the length of the
117 the member "chain" considered as an array. */
120 /* Number of "binding_entry"s in this table. */
124 /* Construct TABLE with an initial CHAIN_COUNT. */
127 binding_table_construct (binding_table table
, size_t chain_count
)
129 table
->chain_count
= chain_count
;
130 table
->entry_count
= 0;
131 table
->chain
= GGC_CNEWVEC (binding_entry
, table
->chain_count
);
134 /* Make TABLE's entries ready for reuse. */
137 binding_table_free (binding_table table
)
145 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
147 binding_entry temp
= table
->chain
[i
];
150 binding_entry entry
= temp
;
152 binding_entry_free (entry
);
154 table
->chain
[i
] = NULL
;
156 table
->entry_count
= 0;
160 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
162 static inline binding_table
163 binding_table_new (size_t chain_count
)
165 binding_table table
= GGC_NEW (struct binding_table_s
);
167 binding_table_construct (table
, chain_count
);
171 /* Expand TABLE to twice its current chain_count. */
174 binding_table_expand (binding_table table
)
176 const size_t old_chain_count
= table
->chain_count
;
177 const size_t old_entry_count
= table
->entry_count
;
178 const size_t new_chain_count
= 2 * old_chain_count
;
179 binding_entry
*old_chains
= table
->chain
;
182 binding_table_construct (table
, new_chain_count
);
183 for (i
= 0; i
< old_chain_count
; ++i
)
185 binding_entry entry
= old_chains
[i
];
186 for (; entry
!= NULL
; entry
= old_chains
[i
])
188 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
189 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
191 old_chains
[i
] = entry
->chain
;
192 entry
->chain
= table
->chain
[j
];
193 table
->chain
[j
] = entry
;
196 table
->entry_count
= old_entry_count
;
199 /* Insert a binding for NAME to TYPE into TABLE. */
202 binding_table_insert (binding_table table
, tree name
, tree type
)
204 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
205 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
206 binding_entry entry
= binding_entry_make (name
, type
);
208 entry
->chain
= table
->chain
[i
];
209 table
->chain
[i
] = entry
;
210 ++table
->entry_count
;
212 if (3 * table
->chain_count
< 5 * table
->entry_count
)
213 binding_table_expand (table
);
216 /* Return the binding_entry, if any, that maps NAME. */
219 binding_table_find (binding_table table
, tree name
)
221 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
222 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
224 while (entry
!= NULL
&& entry
->name
!= name
)
225 entry
= entry
->chain
;
230 /* Apply PROC -- with DATA -- to all entries in TABLE. */
233 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
235 const size_t chain_count
= table
->chain_count
;
238 for (i
= 0; i
< chain_count
; ++i
)
240 binding_entry entry
= table
->chain
[i
];
241 for (; entry
!= NULL
; entry
= entry
->chain
)
246 #ifndef ENABLE_SCOPE_CHECKING
247 # define ENABLE_SCOPE_CHECKING 0
249 # define ENABLE_SCOPE_CHECKING 1
252 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
254 static GTY((deletable
)) cxx_binding
*free_bindings
;
256 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
260 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
262 binding
->value
= value
;
263 binding
->type
= type
;
264 binding
->previous
= NULL
;
267 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
270 cxx_binding_make (tree value
, tree type
)
272 cxx_binding
*binding
;
275 binding
= free_bindings
;
276 free_bindings
= binding
->previous
;
279 binding
= GGC_NEW (cxx_binding
);
281 cxx_binding_init (binding
, value
, type
);
286 /* Put BINDING back on the free list. */
289 cxx_binding_free (cxx_binding
*binding
)
291 binding
->scope
= NULL
;
292 binding
->previous
= free_bindings
;
293 free_bindings
= binding
;
296 /* Create a new binding for NAME (with the indicated VALUE and TYPE
297 bindings) in the class scope indicated by SCOPE. */
300 new_class_binding (tree name
, tree value
, tree type
, cxx_scope
*scope
)
302 cp_class_binding
*cb
;
303 cxx_binding
*binding
;
305 if (VEC_length (cp_class_binding
, scope
->class_shadowed
))
307 cp_class_binding
*old_base
;
308 old_base
= VEC_index (cp_class_binding
, scope
->class_shadowed
, 0);
309 if (VEC_reserve (cp_class_binding
, gc
, scope
->class_shadowed
, 1))
311 /* Fixup the current bindings, as they might have moved. */
315 VEC_iterate (cp_class_binding
, scope
->class_shadowed
, i
, cb
);
319 b
= &IDENTIFIER_BINDING (cb
->identifier
);
320 while (*b
!= &old_base
[i
].base
)
321 b
= &((*b
)->previous
);
325 cb
= VEC_quick_push (cp_class_binding
, scope
->class_shadowed
, NULL
);
328 cb
= VEC_safe_push (cp_class_binding
, gc
, scope
->class_shadowed
, NULL
);
330 cb
->identifier
= name
;
332 binding
->scope
= scope
;
333 cxx_binding_init (binding
, value
, type
);
337 /* Make DECL the innermost binding for ID. The LEVEL is the binding
338 level at which this declaration is being bound. */
341 push_binding (tree id
, tree decl
, cxx_scope
* level
)
343 cxx_binding
*binding
;
345 if (level
!= class_binding_level
)
347 binding
= cxx_binding_make (decl
, NULL_TREE
);
348 binding
->scope
= level
;
351 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
353 /* Now, fill in the binding information. */
354 binding
->previous
= IDENTIFIER_BINDING (id
);
355 INHERITED_VALUE_BINDING_P (binding
) = 0;
356 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
358 /* And put it on the front of the list of bindings for ID. */
359 IDENTIFIER_BINDING (id
) = binding
;
362 /* Remove the binding for DECL which should be the innermost binding
366 pop_binding (tree id
, tree decl
)
368 cxx_binding
*binding
;
371 /* It's easiest to write the loops that call this function without
372 checking whether or not the entities involved have names. We
373 get here for such an entity. */
376 /* Get the innermost binding for ID. */
377 binding
= IDENTIFIER_BINDING (id
);
379 /* The name should be bound. */
380 gcc_assert (binding
!= NULL
);
382 /* The DECL will be either the ordinary binding or the type
383 binding for this identifier. Remove that binding. */
384 if (binding
->value
== decl
)
385 binding
->value
= NULL_TREE
;
388 gcc_assert (binding
->type
== decl
);
389 binding
->type
= NULL_TREE
;
392 if (!binding
->value
&& !binding
->type
)
394 /* We're completely done with the innermost binding for this
395 identifier. Unhook it from the list of bindings. */
396 IDENTIFIER_BINDING (id
) = binding
->previous
;
398 /* Add it to the free list. */
399 cxx_binding_free (binding
);
403 /* BINDING records an existing declaration for a name in the current scope.
404 But, DECL is another declaration for that same identifier in the
405 same scope. This is the `struct stat' hack whereby a non-typedef
406 class name or enum-name can be bound at the same level as some other
410 A class name (9.1) or enumeration name (7.2) can be hidden by the
411 name of an object, function, or enumerator declared in the same scope.
412 If a class or enumeration name and an object, function, or enumerator
413 are declared in the same scope (in any order) with the same name, the
414 class or enumeration name is hidden wherever the object, function, or
415 enumerator name is visible.
417 It's the responsibility of the caller to check that
418 inserting this name is valid here. Returns nonzero if the new binding
422 supplement_binding (cxx_binding
*binding
, tree decl
)
424 tree bval
= binding
->value
;
427 timevar_push (TV_NAME_LOOKUP
);
428 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
429 /* The new name is the type name. */
430 binding
->type
= decl
;
431 else if (/* BVAL is null when push_class_level_binding moves an
432 inherited type-binding out of the way to make room for a
433 new value binding. */
435 /* BVAL is error_mark_node when DECL's name has been used
436 in a non-class scope prior declaration. In that case,
437 we should have already issued a diagnostic; for graceful
438 error recovery purpose, pretend this was the intended
439 declaration for that name. */
440 || bval
== error_mark_node
441 /* If BVAL is anticipated but has not yet been declared,
442 pretend it is not there at all. */
443 || (TREE_CODE (bval
) == FUNCTION_DECL
444 && DECL_ANTICIPATED (bval
)
445 && !DECL_HIDDEN_FRIEND_P (bval
)))
446 binding
->value
= decl
;
447 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
449 /* The old binding was a type name. It was placed in
450 VALUE field because it was thought, at the point it was
451 declared, to be the only entity with such a name. Move the
452 type name into the type slot; it is now hidden by the new
454 binding
->type
= bval
;
455 binding
->value
= decl
;
456 binding
->value_is_inherited
= false;
458 else if (TREE_CODE (bval
) == TYPE_DECL
459 && TREE_CODE (decl
) == TYPE_DECL
460 && DECL_NAME (decl
) == DECL_NAME (bval
)
461 && binding
->scope
->kind
!= sk_class
462 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
463 /* If either type involves template parameters, we must
464 wait until instantiation. */
465 || uses_template_parms (TREE_TYPE (decl
))
466 || uses_template_parms (TREE_TYPE (bval
))))
467 /* We have two typedef-names, both naming the same type to have
468 the same name. In general, this is OK because of:
472 In a given scope, a typedef specifier can be used to redefine
473 the name of any type declared in that scope to refer to the
474 type to which it already refers.
476 However, in class scopes, this rule does not apply due to the
477 stricter language in [class.mem] prohibiting redeclarations of
480 /* There can be two block-scope declarations of the same variable,
481 so long as they are `extern' declarations. However, there cannot
482 be two declarations of the same static data member:
486 A member shall not be declared twice in the
487 member-specification. */
488 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
489 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
490 && !DECL_CLASS_SCOPE_P (decl
))
492 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
495 else if (TREE_CODE (decl
) == NAMESPACE_DECL
496 && TREE_CODE (bval
) == NAMESPACE_DECL
497 && DECL_NAMESPACE_ALIAS (decl
)
498 && DECL_NAMESPACE_ALIAS (bval
)
499 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
502 In a declarative region, a namespace-alias-definition can be
503 used to redefine a namespace-alias declared in that declarative
504 region to refer only to the namespace to which it already
509 error ("declaration of %q#D", decl
);
510 error ("conflicts with previous declaration %q+#D", bval
);
514 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
517 /* Add DECL to the list of things declared in B. */
520 add_decl_to_level (tree decl
, cxx_scope
*b
)
522 if (TREE_CODE (decl
) == NAMESPACE_DECL
523 && !DECL_NAMESPACE_ALIAS (decl
))
525 TREE_CHAIN (decl
) = b
->namespaces
;
526 b
->namespaces
= decl
;
528 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
530 TREE_CHAIN (decl
) = b
->vtables
;
535 /* We build up the list in reverse order, and reverse it later if
537 TREE_CHAIN (decl
) = b
->names
;
541 /* If appropriate, add decl to separate list of statics. We
542 include extern variables because they might turn out to be
543 static later. It's OK for this list to contain a few false
545 if (b
->kind
== sk_namespace
)
546 if ((TREE_CODE (decl
) == VAR_DECL
547 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
548 || (TREE_CODE (decl
) == FUNCTION_DECL
549 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
550 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
554 /* Record a decl-node X as belonging to the current lexical scope.
555 Check for errors (such as an incompatible declaration for the same
556 name already seen in the same scope). IS_FRIEND is true if X is
557 declared as a friend.
559 Returns either X or an old decl for the same name.
560 If an old decl is returned, it may have been smashed
561 to agree with what X says. */
564 pushdecl_maybe_friend (tree x
, bool is_friend
)
568 int need_new_binding
;
570 timevar_push (TV_NAME_LOOKUP
);
572 need_new_binding
= 1;
574 if (DECL_TEMPLATE_PARM_P (x
))
575 /* Template parameters have no context; they are not X::T even
576 when declared within a class or namespace. */
580 if (current_function_decl
&& x
!= current_function_decl
581 /* A local declaration for a function doesn't constitute
583 && TREE_CODE (x
) != FUNCTION_DECL
584 /* A local declaration for an `extern' variable is in the
585 scope of the current namespace, not the current
587 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
588 && !DECL_CONTEXT (x
))
589 DECL_CONTEXT (x
) = current_function_decl
;
591 /* If this is the declaration for a namespace-scope function,
592 but the declaration itself is in a local scope, mark the
594 if (TREE_CODE (x
) == FUNCTION_DECL
595 && DECL_NAMESPACE_SCOPE_P (x
)
596 && current_function_decl
597 && x
!= current_function_decl
)
598 DECL_LOCAL_FUNCTION_P (x
) = 1;
601 name
= DECL_NAME (x
);
604 int different_binding_level
= 0;
606 if (TREE_CODE (x
) == FUNCTION_DECL
|| DECL_FUNCTION_TEMPLATE_P (x
))
607 check_default_args (x
);
609 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
610 name
= TREE_OPERAND (name
, 0);
612 /* In case this decl was explicitly namespace-qualified, look it
613 up in its namespace context. */
614 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
615 t
= namespace_binding (name
, DECL_CONTEXT (x
));
617 t
= lookup_name_innermost_nonclass_level (name
);
619 /* [basic.link] If there is a visible declaration of an entity
620 with linkage having the same name and type, ignoring entities
621 declared outside the innermost enclosing namespace scope, the
622 block scope declaration declares that same entity and
623 receives the linkage of the previous declaration. */
624 if (! t
&& current_function_decl
&& x
!= current_function_decl
625 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
626 && DECL_EXTERNAL (x
))
628 /* Look in block scope. */
629 t
= innermost_non_namespace_value (name
);
630 /* Or in the innermost namespace. */
632 t
= namespace_binding (name
, DECL_CONTEXT (x
));
633 /* Does it have linkage? Note that if this isn't a DECL, it's an
634 OVERLOAD, which is OK. */
635 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
638 different_binding_level
= 1;
641 /* If we are declaring a function, and the result of name-lookup
642 was an OVERLOAD, look for an overloaded instance that is
643 actually the same as the function we are declaring. (If
644 there is one, we have to merge our declaration with the
645 previous declaration.) */
646 if (t
&& TREE_CODE (t
) == OVERLOAD
)
650 if (TREE_CODE (x
) == FUNCTION_DECL
)
651 for (match
= t
; match
; match
= OVL_NEXT (match
))
653 if (decls_match (OVL_CURRENT (match
), x
))
657 /* Just choose one. */
661 t
= OVL_CURRENT (match
);
666 if (t
&& t
!= error_mark_node
)
668 if (different_binding_level
)
670 if (decls_match (x
, t
))
671 /* The standard only says that the local extern
672 inherits linkage from the previous decl; in
673 particular, default args are not shared. We must
674 also tell cgraph to treat these decls as the same,
675 or we may neglect to emit an "unused" static - we
676 do this by making the DECL_UIDs equal, which should
677 be viewed as a kludge. FIXME. */
679 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
680 DECL_UID (x
) = DECL_UID (t
);
683 else if (TREE_CODE (t
) == PARM_DECL
)
685 gcc_assert (DECL_CONTEXT (t
));
687 /* Check for duplicate params. */
688 if (duplicate_decls (x
, t
, is_friend
))
689 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
691 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
692 || DECL_FUNCTION_TEMPLATE_P (x
))
693 && is_overloaded_fn (t
))
694 /* Don't do anything just yet. */;
695 else if (t
== wchar_decl_node
)
697 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
698 pedwarn ("redeclaration of %<wchar_t%> as %qT",
701 /* Throw away the redeclaration. */
702 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
706 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
708 /* If the redeclaration failed, we can stop at this
710 if (olddecl
== error_mark_node
)
711 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
715 if (TREE_CODE (t
) == TYPE_DECL
)
716 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
718 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
720 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
722 /* A redeclaration of main, but not a duplicate of the
727 This function shall not be overloaded. */
728 error ("invalid redeclaration of %q+D", t
);
730 /* We don't try to push this declaration since that
732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
737 check_template_shadow (x
);
739 /* If this is a function conjured up by the backend, massage it
740 so it looks friendly. */
741 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
743 retrofit_lang_decl (x
);
744 SET_DECL_LANGUAGE (x
, lang_c
);
747 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
749 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
751 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
752 if (!namespace_bindings_p ())
753 /* We do not need to create a binding for this name;
754 push_overloaded_decl will have already done so if
756 need_new_binding
= 0;
758 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
760 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
762 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
763 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
766 /* If declaring a type as a typedef, copy the type (unless we're
767 at line 0), and install this TYPE_DECL as the new type's typedef
768 name. See the extensive comment in ../c-decl.c (pushdecl). */
769 if (TREE_CODE (x
) == TYPE_DECL
)
771 tree type
= TREE_TYPE (x
);
772 if (DECL_IS_BUILTIN (x
))
774 if (TYPE_NAME (type
) == 0)
775 TYPE_NAME (type
) = x
;
777 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
778 /* We don't want to copy the type when all we're
779 doing is making a TYPE_DECL for the purposes of
781 && (!TYPE_NAME (type
)
782 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
784 DECL_ORIGINAL_TYPE (x
) = type
;
785 type
= build_variant_type_copy (type
);
786 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
787 TYPE_NAME (type
) = x
;
788 TREE_TYPE (x
) = type
;
791 if (type
!= error_mark_node
793 && TYPE_IDENTIFIER (type
))
794 set_identifier_type_value (DECL_NAME (x
), x
);
797 /* Multiple external decls of the same identifier ought to match.
799 We get warnings about inline functions where they are defined.
800 We get warnings about other functions from push_overloaded_decl.
802 Avoid duplicate warnings where they are used. */
803 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
807 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
808 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
809 decl
= OVL_FUNCTION (decl
);
811 if (decl
&& decl
!= error_mark_node
812 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
813 /* If different sort of thing, we already gave an error. */
814 && TREE_CODE (decl
) == TREE_CODE (x
)
815 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
817 pedwarn ("type mismatch with previous external decl of %q#D", x
);
818 pedwarn ("previous external decl of %q+#D", decl
);
822 if (TREE_CODE (x
) == FUNCTION_DECL
824 && !flag_friend_injection
)
826 /* This is a new declaration of a friend function, so hide
827 it from ordinary function lookup. */
828 DECL_ANTICIPATED (x
) = 1;
829 DECL_HIDDEN_FRIEND_P (x
) = 1;
832 /* This name is new in its binding level.
833 Install the new declaration and return it. */
834 if (namespace_bindings_p ())
836 /* Install a global value. */
838 /* If the first global decl has external linkage,
839 warn if we later see static one. */
840 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
841 TREE_PUBLIC (name
) = 1;
843 /* Bind the name for the entity. */
844 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
846 && (TREE_CODE (x
) == TYPE_DECL
847 || TREE_CODE (x
) == VAR_DECL
848 || TREE_CODE (x
) == NAMESPACE_DECL
849 || TREE_CODE (x
) == CONST_DECL
850 || TREE_CODE (x
) == TEMPLATE_DECL
))
851 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
853 /* If new decl is `static' and an `extern' was seen previously,
855 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
856 warn_extern_redeclared_static (x
, t
);
860 /* Here to install a non-global value. */
861 tree oldlocal
= innermost_non_namespace_value (name
);
862 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
864 if (need_new_binding
)
866 push_local_binding (name
, x
, 0);
867 /* Because push_local_binding will hook X on to the
868 current_binding_level's name list, we don't want to
869 do that again below. */
870 need_new_binding
= 0;
873 /* If this is a TYPE_DECL, push it into the type value slot. */
874 if (TREE_CODE (x
) == TYPE_DECL
)
875 set_identifier_type_value (name
, x
);
877 /* Clear out any TYPE_DECL shadowed by a namespace so that
878 we won't think this is a type. The C struct hack doesn't
879 go through namespaces. */
880 if (TREE_CODE (x
) == NAMESPACE_DECL
)
881 set_identifier_type_value (name
, NULL_TREE
);
888 && TREE_CODE (oldlocal
) == VAR_DECL
889 && DECL_DEAD_FOR_LOCAL (oldlocal
))
890 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
892 if (oldlocal
== NULL_TREE
)
893 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
896 /* If this is an extern function declaration, see if we
897 have a global definition or declaration for the function. */
898 if (oldlocal
== NULL_TREE
900 && oldglobal
!= NULL_TREE
901 && TREE_CODE (x
) == FUNCTION_DECL
902 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
904 /* We have one. Their types must agree. */
905 if (decls_match (x
, oldglobal
))
909 warning (0, "extern declaration of %q#D doesn't match", x
);
910 warning (0, "global declaration %q+#D", oldglobal
);
913 /* If we have a local external declaration,
914 and no file-scope declaration has yet been seen,
915 then if we later have a file-scope decl it must not be static. */
916 if (oldlocal
== NULL_TREE
917 && oldglobal
== NULL_TREE
920 TREE_PUBLIC (name
) = 1;
922 /* Warn if shadowing an argument at the top level of the body. */
923 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
924 /* Inline decls shadow nothing. */
925 && !DECL_FROM_INLINE (x
)
926 && TREE_CODE (oldlocal
) == PARM_DECL
927 /* Don't check the `this' parameter. */
928 && !DECL_ARTIFICIAL (oldlocal
))
932 /* Don't complain if it's from an enclosing function. */
933 if (DECL_CONTEXT (oldlocal
) == current_function_decl
934 && TREE_CODE (x
) != PARM_DECL
)
936 /* Go to where the parms should be and see if we find
938 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
940 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
941 /* Skip the ctor/dtor cleanup level. */
945 if (b
->kind
== sk_function_parms
)
947 error ("declaration of %q#D shadows a parameter", x
);
952 if (warn_shadow
&& !err
)
954 warning (OPT_Wshadow
, "declaration of %q#D shadows a parameter", x
);
955 warning (OPT_Wshadow
, "%Jshadowed declaration is here", oldlocal
);
959 /* Maybe warn if shadowing something else. */
960 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
961 /* No shadow warnings for internally generated vars. */
962 && ! DECL_ARTIFICIAL (x
)
963 /* No shadow warnings for vars made for inlining. */
964 && ! DECL_FROM_INLINE (x
))
968 if (current_class_ptr
)
969 member
= lookup_member (current_class_type
,
972 /*want_type=*/false);
976 if (member
&& !TREE_STATIC (member
))
978 /* Location of previous decl is not useful in this case. */
979 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
982 else if (oldlocal
!= NULL_TREE
983 && TREE_CODE (oldlocal
) == VAR_DECL
)
985 warning (OPT_Wshadow
, "declaration of %qD shadows a previous local", x
);
986 warning (OPT_Wshadow
, "%Jshadowed declaration is here", oldlocal
);
988 else if (oldglobal
!= NULL_TREE
989 && TREE_CODE (oldglobal
) == VAR_DECL
)
990 /* XXX shadow warnings in outer-more namespaces */
992 warning (OPT_Wshadow
, "declaration of %qD shadows a global declaration",
994 warning (OPT_Wshadow
, "%Jshadowed declaration is here", oldglobal
);
999 if (TREE_CODE (x
) == VAR_DECL
)
1000 maybe_register_incomplete_var (x
);
1003 if (need_new_binding
)
1004 add_decl_to_level (x
,
1005 DECL_NAMESPACE_SCOPE_P (x
)
1006 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1007 : current_binding_level
);
1009 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1012 /* Record a decl-node X as belonging to the current lexical scope. */
1017 return pushdecl_maybe_friend (x
, false);
1020 /* Enter DECL into the symbol table, if that's appropriate. Returns
1021 DECL, or a modified version thereof. */
1024 maybe_push_decl (tree decl
)
1026 tree type
= TREE_TYPE (decl
);
1028 /* Add this decl to the current binding level, but not if it comes
1029 from another scope, e.g. a static member variable. TEM may equal
1030 DECL or it may be a previous decl of the same name. */
1031 if (decl
== error_mark_node
1032 || (TREE_CODE (decl
) != PARM_DECL
1033 && DECL_CONTEXT (decl
) != NULL_TREE
1034 /* Definitions of namespace members outside their namespace are
1036 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
1037 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1038 || TREE_CODE (type
) == UNKNOWN_TYPE
1039 /* The declaration of a template specialization does not affect
1040 the functions available for overload resolution, so we do not
1042 || (TREE_CODE (decl
) == FUNCTION_DECL
1043 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1046 return pushdecl (decl
);
1049 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1050 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1051 doesn't really belong to this binding level, that it got here
1052 through a using-declaration. */
1055 push_local_binding (tree id
, tree decl
, int flags
)
1057 struct cp_binding_level
*b
;
1059 /* Skip over any local classes. This makes sense if we call
1060 push_local_binding with a friend decl of a local class. */
1061 b
= innermost_nonclass_level ();
1063 if (lookup_name_innermost_nonclass_level (id
))
1065 /* Supplement the existing binding. */
1066 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1067 /* It didn't work. Something else must be bound at this
1068 level. Do not add DECL to the list of things to pop
1073 /* Create a new binding. */
1074 push_binding (id
, decl
, b
);
1076 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1077 /* We must put the OVERLOAD into a TREE_LIST since the
1078 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1079 decls that got here through a using-declaration. */
1080 decl
= build_tree_list (NULL_TREE
, decl
);
1082 /* And put DECL on the list of things declared by the current
1084 add_decl_to_level (decl
, b
);
1087 /* Check to see whether or not DECL is a variable that would have been
1088 in scope under the ARM, but is not in scope under the ANSI/ISO
1089 standard. If so, issue an error message. If name lookup would
1090 work in both cases, but return a different result, this function
1091 returns the result of ANSI/ISO lookup. Otherwise, it returns
1095 check_for_out_of_scope_variable (tree decl
)
1099 /* We only care about out of scope variables. */
1100 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1103 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1104 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1105 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1106 && DECL_DEAD_FOR_LOCAL (shadowed
))
1107 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1108 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1110 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1113 if (!DECL_ERROR_REPORTED (decl
))
1115 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1116 warning (0, " matches this %q+D under ISO standard rules",
1118 warning (0, " matches this %q+D under old rules", decl
);
1119 DECL_ERROR_REPORTED (decl
) = 1;
1124 /* If we have already complained about this declaration, there's no
1125 need to do it again. */
1126 if (DECL_ERROR_REPORTED (decl
))
1129 DECL_ERROR_REPORTED (decl
) = 1;
1131 if (TREE_TYPE (decl
) == error_mark_node
)
1134 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1136 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1138 error (" cannot use obsolete binding at %q+D because "
1139 "it has a destructor", decl
);
1140 return error_mark_node
;
1144 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1146 pedwarn (" using obsolete binding at %q+D", decl
);
1152 /* true means unconditionally make a BLOCK for the next level pushed. */
1154 static bool keep_next_level_flag
;
1156 static int binding_depth
= 0;
1157 static int is_class_level
= 0;
1164 for (i
= 0; i
< depth
* 2; i
++)
1168 /* Return a string describing the kind of SCOPE we have. */
1170 cxx_scope_descriptor (cxx_scope
*scope
)
1172 /* The order of this table must match the "scope_kind"
1174 static const char* scope_kind_names
[] = {
1180 "function-parameter-scope",
1183 "template-parameter-scope",
1184 "template-explicit-spec-scope"
1186 const scope_kind kind
= scope
->explicit_spec_p
1187 ? sk_template_spec
: scope
->kind
;
1189 return scope_kind_names
[kind
];
1192 /* Output a debugging information about SCOPE when performing
1195 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1197 const char *desc
= cxx_scope_descriptor (scope
);
1198 if (scope
->this_entity
)
1199 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1200 scope
->this_entity
, (void *) scope
, line
);
1202 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1205 /* Return the estimated initial size of the hashtable of a NAMESPACE
1208 static inline size_t
1209 namespace_scope_ht_size (tree ns
)
1211 tree name
= DECL_NAME (ns
);
1213 return name
== std_identifier
1214 ? NAMESPACE_STD_HT_SIZE
1215 : (name
== global_scope_name
1216 ? GLOBAL_SCOPE_HT_SIZE
1217 : NAMESPACE_ORDINARY_HT_SIZE
);
1220 /* A chain of binding_level structures awaiting reuse. */
1222 static GTY((deletable
)) struct cp_binding_level
*free_binding_level
;
1224 /* Insert SCOPE as the innermost binding level. */
1227 push_binding_level (struct cp_binding_level
*scope
)
1229 /* Add it to the front of currently active scopes stack. */
1230 scope
->level_chain
= current_binding_level
;
1231 current_binding_level
= scope
;
1232 keep_next_level_flag
= false;
1234 if (ENABLE_SCOPE_CHECKING
)
1236 scope
->binding_depth
= binding_depth
;
1237 indent (binding_depth
);
1238 cxx_scope_debug (scope
, input_line
, "push");
1244 /* Create a new KIND scope and make it the top of the active scopes stack.
1245 ENTITY is the scope of the associated C++ entity (namespace, class,
1246 function); it is NULL otherwise. */
1249 begin_scope (scope_kind kind
, tree entity
)
1253 /* Reuse or create a struct for this binding level. */
1254 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1256 scope
= free_binding_level
;
1257 free_binding_level
= scope
->level_chain
;
1260 scope
= GGC_NEW (cxx_scope
);
1261 memset (scope
, 0, sizeof (cxx_scope
));
1263 scope
->this_entity
= entity
;
1264 scope
->more_cleanups_ok
= true;
1271 case sk_template_spec
:
1272 scope
->explicit_spec_p
= true;
1273 kind
= sk_template_parms
;
1275 case sk_template_parms
:
1281 case sk_function_parms
:
1283 scope
->keep
= keep_next_level_flag
;
1287 NAMESPACE_LEVEL (entity
) = scope
;
1288 scope
->static_decls
=
1289 VEC_alloc (tree
, gc
,
1290 DECL_NAME (entity
) == std_identifier
1291 || DECL_NAME (entity
) == global_scope_name
1296 /* Should not happen. */
1302 push_binding_level (scope
);
1307 /* We're about to leave current scope. Pop the top of the stack of
1308 currently active scopes. Return the enclosing scope, now active. */
1313 cxx_scope
*scope
= current_binding_level
;
1315 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1316 current_binding_level
= class_binding_level
;
1318 /* We cannot leave a scope, if there are none left. */
1319 if (NAMESPACE_LEVEL (global_namespace
))
1320 gcc_assert (!global_scope_p (scope
));
1322 if (ENABLE_SCOPE_CHECKING
)
1324 indent (--binding_depth
);
1325 cxx_scope_debug (scope
, input_line
, "leave");
1326 if (is_class_level
!= (scope
== class_binding_level
))
1328 indent (binding_depth
);
1329 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1334 #ifdef HANDLE_PRAGMA_VISIBILITY
1335 if (scope
->has_visibility
)
1339 /* Move one nesting level up. */
1340 current_binding_level
= scope
->level_chain
;
1342 /* Namespace-scopes are left most probably temporarily, not
1343 completely; they can be reopened later, e.g. in namespace-extension
1344 or any name binding activity that requires us to resume a
1345 namespace. For classes, we cache some binding levels. For other
1346 scopes, we just make the structure available for reuse. */
1347 if (scope
->kind
!= sk_namespace
1348 && scope
->kind
!= sk_class
)
1350 scope
->level_chain
= free_binding_level
;
1351 gcc_assert (!ENABLE_SCOPE_CHECKING
1352 || scope
->binding_depth
== binding_depth
);
1353 free_binding_level
= scope
;
1356 /* Find the innermost enclosing class scope, and reset
1357 CLASS_BINDING_LEVEL appropriately. */
1358 if (scope
->kind
== sk_class
)
1360 class_binding_level
= NULL
;
1361 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1362 if (scope
->kind
== sk_class
)
1364 class_binding_level
= scope
;
1369 return current_binding_level
;
1373 resume_scope (struct cp_binding_level
* b
)
1375 /* Resuming binding levels is meant only for namespaces,
1376 and those cannot nest into classes. */
1377 gcc_assert (!class_binding_level
);
1378 /* Also, resuming a non-directly nested namespace is a no-no. */
1379 gcc_assert (b
->level_chain
== current_binding_level
);
1380 current_binding_level
= b
;
1381 if (ENABLE_SCOPE_CHECKING
)
1383 b
->binding_depth
= binding_depth
;
1384 indent (binding_depth
);
1385 cxx_scope_debug (b
, input_line
, "resume");
1391 /* Return the innermost binding level that is not for a class scope. */
1394 innermost_nonclass_level (void)
1398 b
= current_binding_level
;
1399 while (b
->kind
== sk_class
)
1405 /* We're defining an object of type TYPE. If it needs a cleanup, but
1406 we're not allowed to add any more objects with cleanups to the current
1407 scope, create a new binding level. */
1410 maybe_push_cleanup_level (tree type
)
1412 if (type
!= error_mark_node
1413 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1414 && current_binding_level
->more_cleanups_ok
== 0)
1416 begin_scope (sk_cleanup
, NULL
);
1417 current_binding_level
->statement_list
= push_stmt_list ();
1421 /* Nonzero if we are currently in the global binding level. */
1424 global_bindings_p (void)
1426 return global_scope_p (current_binding_level
);
1429 /* True if we are currently in a toplevel binding level. This
1430 means either the global binding level or a namespace in a toplevel
1431 binding level. Since there are no non-toplevel namespace levels,
1432 this really means any namespace or template parameter level. We
1433 also include a class whose context is toplevel. */
1436 toplevel_bindings_p (void)
1438 struct cp_binding_level
*b
= innermost_nonclass_level ();
1440 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1443 /* True if this is a namespace scope, or if we are defining a class
1444 which is itself at namespace scope, or whose enclosing class is
1445 such a class, etc. */
1448 namespace_bindings_p (void)
1450 struct cp_binding_level
*b
= innermost_nonclass_level ();
1452 return b
->kind
== sk_namespace
;
1455 /* True if the current level needs to have a BLOCK made. */
1460 return (current_binding_level
->blocks
!= NULL_TREE
1461 || current_binding_level
->keep
1462 || current_binding_level
->kind
== sk_cleanup
1463 || current_binding_level
->names
!= NULL_TREE
);
1466 /* Returns the kind of the innermost scope. */
1469 innermost_scope_kind (void)
1471 return current_binding_level
->kind
;
1474 /* Returns true if this scope was created to store template parameters. */
1477 template_parm_scope_p (void)
1479 return innermost_scope_kind () == sk_template_parms
;
1482 /* If KEEP is true, make a BLOCK node for the next binding level,
1483 unconditionally. Otherwise, use the normal logic to decide whether
1484 or not to create a BLOCK. */
1487 keep_next_level (bool keep
)
1489 keep_next_level_flag
= keep
;
1492 /* Return the list of declarations of the current level.
1493 Note that this list is in reverse order unless/until
1494 you nreverse it; and when you do nreverse it, you must
1495 store the result back using `storedecls' or you will lose. */
1500 return current_binding_level
->names
;
1503 /* For debugging. */
1504 static int no_print_functions
= 0;
1505 static int no_print_builtins
= 0;
1508 print_binding_level (struct cp_binding_level
* lvl
)
1512 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1513 if (lvl
->more_cleanups_ok
)
1514 fprintf (stderr
, " more-cleanups-ok");
1515 if (lvl
->have_cleanups
)
1516 fprintf (stderr
, " have-cleanups");
1517 fprintf (stderr
, "\n");
1520 fprintf (stderr
, " names:\t");
1521 /* We can probably fit 3 names to a line? */
1522 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1524 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1526 if (no_print_builtins
1527 && (TREE_CODE (t
) == TYPE_DECL
)
1528 && DECL_IS_BUILTIN (t
))
1531 /* Function decls tend to have longer names. */
1532 if (TREE_CODE (t
) == FUNCTION_DECL
)
1539 fprintf (stderr
, "\n\t");
1542 print_node_brief (stderr
, "", t
, 0);
1543 if (t
== error_mark_node
)
1547 fprintf (stderr
, "\n");
1549 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1552 cp_class_binding
*b
;
1553 fprintf (stderr
, " class-shadowed:");
1555 VEC_iterate(cp_class_binding
, lvl
->class_shadowed
, i
, b
);
1557 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1558 fprintf (stderr
, "\n");
1560 if (lvl
->type_shadowed
)
1562 fprintf (stderr
, " type-shadowed:");
1563 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1565 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1567 fprintf (stderr
, "\n");
1572 print_other_binding_stack (struct cp_binding_level
*stack
)
1574 struct cp_binding_level
*level
;
1575 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1577 fprintf (stderr
, "binding level %p\n", (void *) level
);
1578 print_binding_level (level
);
1583 print_binding_stack (void)
1585 struct cp_binding_level
*b
;
1586 fprintf (stderr
, "current_binding_level=%p\n"
1587 "class_binding_level=%p\n"
1588 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1589 (void *) current_binding_level
, (void *) class_binding_level
,
1590 (void *) NAMESPACE_LEVEL (global_namespace
));
1591 if (class_binding_level
)
1593 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1594 if (b
== current_binding_level
)
1597 b
= class_binding_level
;
1599 b
= current_binding_level
;
1602 b
= current_binding_level
;
1603 print_other_binding_stack (b
);
1604 fprintf (stderr
, "global:\n");
1605 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1608 /* Return the type associated with id. */
1611 identifier_type_value (tree id
)
1613 timevar_push (TV_NAME_LOOKUP
);
1614 /* There is no type with that name, anywhere. */
1615 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1616 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1617 /* This is not the type marker, but the real thing. */
1618 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1619 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, REAL_IDENTIFIER_TYPE_VALUE (id
));
1620 /* Have to search for it. It must be on the global level, now.
1621 Ask lookup_name not to return non-types. */
1622 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1624 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, TREE_TYPE (id
));
1625 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1628 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1629 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1632 identifier_global_value (tree t
)
1634 return IDENTIFIER_GLOBAL_VALUE (t
);
1637 /* Push a definition of struct, union or enum tag named ID. into
1638 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1639 the tag ID is not already defined. */
1642 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1646 if (b
->kind
!= sk_namespace
)
1648 /* Shadow the marker, not the real thing, so that the marker
1649 gets restored later. */
1650 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1652 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1653 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1654 TREE_TYPE (b
->type_shadowed
) = type
;
1658 cxx_binding
*binding
=
1659 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1662 supplement_binding (binding
, decl
);
1664 binding
->value
= decl
;
1666 /* Store marker instead of real type. */
1667 type
= global_type_node
;
1669 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1672 /* As set_identifier_type_value_with_scope, but using
1673 current_binding_level. */
1676 set_identifier_type_value (tree id
, tree decl
)
1678 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1681 /* Return the name for the constructor (or destructor) for the
1682 specified class TYPE. When given a template, this routine doesn't
1683 lose the specialization. */
1686 constructor_name_full (tree type
)
1688 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1691 /* Return the name for the constructor (or destructor) for the
1692 specified class. When given a template, return the plain
1693 unspecialized name. */
1696 constructor_name (tree type
)
1699 name
= constructor_name_full (type
);
1700 if (IDENTIFIER_TEMPLATE (name
))
1701 name
= IDENTIFIER_TEMPLATE (name
);
1705 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1708 constructor_name_p (tree name
, tree type
)
1715 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1718 ctor_name
= constructor_name_full (type
);
1719 if (name
== ctor_name
)
1721 if (IDENTIFIER_TEMPLATE (ctor_name
)
1722 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1727 /* Counter used to create anonymous type names. */
1729 static GTY(()) int anon_cnt
;
1731 /* Return an IDENTIFIER which can be used as a name for
1732 anonymous structs and unions. */
1735 make_anon_name (void)
1739 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1740 return get_identifier (buf
);
1743 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1745 static inline cxx_binding
*
1746 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1748 timevar_push (TV_NAME_LOOKUP
);
1750 for (; binding
!= NULL
; binding
= binding
->previous
)
1751 if (binding
->scope
== scope
)
1752 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
);
1754 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, (cxx_binding
*)0);
1757 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1759 static inline cxx_binding
*
1760 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1762 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1765 /* Fold-in case where NAME is used only once. */
1766 if (scope
== b
->scope
&& b
->previous
== NULL
)
1768 return find_binding (scope
, b
);
1773 /* Always returns a binding for name in scope. If no binding is
1774 found, make a new one. */
1776 static cxx_binding
*
1777 binding_for_name (cxx_scope
*scope
, tree name
)
1779 cxx_binding
*result
;
1781 result
= cxx_scope_find_binding_for_name (scope
, name
);
1784 /* Not found, make a new one. */
1785 result
= cxx_binding_make (NULL
, NULL
);
1786 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1787 result
->scope
= scope
;
1788 result
->is_local
= false;
1789 result
->value_is_inherited
= false;
1790 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1794 /* Insert another USING_DECL into the current binding level, returning
1795 this declaration. If this is a redeclaration, do nothing, and
1796 return NULL_TREE if this not in namespace scope (in namespace
1797 scope, a using decl might extend any previous bindings). */
1800 push_using_decl (tree scope
, tree name
)
1804 timevar_push (TV_NAME_LOOKUP
);
1805 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
1806 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1807 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
1808 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
1811 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
1812 namespace_bindings_p () ? decl
: NULL_TREE
);
1813 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
1814 USING_DECL_SCOPE (decl
) = scope
;
1815 TREE_CHAIN (decl
) = current_binding_level
->usings
;
1816 current_binding_level
->usings
= decl
;
1817 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1820 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1821 caller to set DECL_CONTEXT properly. */
1824 pushdecl_with_scope (tree x
, cxx_scope
*level
, bool is_friend
)
1826 struct cp_binding_level
*b
;
1827 tree function_decl
= current_function_decl
;
1829 timevar_push (TV_NAME_LOOKUP
);
1830 current_function_decl
= NULL_TREE
;
1831 if (level
->kind
== sk_class
)
1833 b
= class_binding_level
;
1834 class_binding_level
= level
;
1835 pushdecl_class_level (x
);
1836 class_binding_level
= b
;
1840 b
= current_binding_level
;
1841 current_binding_level
= level
;
1842 x
= pushdecl_maybe_friend (x
, is_friend
);
1843 current_binding_level
= b
;
1845 current_function_decl
= function_decl
;
1846 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1849 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1850 other definitions already in place. We get around this by making
1851 the value of the identifier point to a list of all the things that
1852 want to be referenced by that name. It is then up to the users of
1853 that name to decide what to do with that list.
1855 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1856 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1858 FLAGS is a bitwise-or of the following values:
1859 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1861 PUSH_USING: DECL is being pushed as the result of a using
1864 IS_FRIEND is true if this is a friend declaration.
1866 The value returned may be a previous declaration if we guessed wrong
1867 about what language DECL should belong to (C or C++). Otherwise,
1868 it's always DECL (and never something that's not a _DECL). */
1871 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
1873 tree name
= DECL_NAME (decl
);
1876 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
1878 timevar_push (TV_NAME_LOOKUP
);
1880 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
1882 old
= lookup_name_innermost_nonclass_level (name
);
1886 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
1888 tree t
= TREE_TYPE (old
);
1889 if (IS_AGGR_TYPE (t
) && warn_shadow
1890 && (! DECL_IN_SYSTEM_HEADER (decl
)
1891 || ! DECL_IN_SYSTEM_HEADER (old
)))
1892 warning (0, "%q#D hides constructor for %q#T", decl
, t
);
1895 else if (is_overloaded_fn (old
))
1899 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
1901 tree fn
= OVL_CURRENT (tmp
);
1904 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
1905 && !(flags
& PUSH_USING
)
1906 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1907 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
1908 && ! decls_match (fn
, decl
))
1909 error ("%q#D conflicts with previous using declaration %q#D",
1912 dup
= duplicate_decls (decl
, fn
, is_friend
);
1913 /* If DECL was a redeclaration of FN -- even an invalid
1914 one -- pass that information along to our caller. */
1915 if (dup
== fn
|| dup
== error_mark_node
)
1916 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, dup
);
1919 /* We don't overload implicit built-ins. duplicate_decls()
1920 may fail to merge the decls if the new decl is e.g. a
1921 template function. */
1922 if (TREE_CODE (old
) == FUNCTION_DECL
1923 && DECL_ANTICIPATED (old
)
1924 && !DECL_HIDDEN_FRIEND_P (old
))
1927 else if (old
== error_mark_node
)
1928 /* Ignore the undefined symbol marker. */
1932 error ("previous non-function declaration %q+#D", old
);
1933 error ("conflicts with function declaration %q#D", decl
);
1934 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1938 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
1939 /* If it's a using declaration, we always need to build an OVERLOAD,
1940 because it's the only way to remember that the declaration comes
1941 from 'using', and have the lookup behave correctly. */
1942 || (flags
& PUSH_USING
))
1944 if (old
&& TREE_CODE (old
) != OVERLOAD
)
1945 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
1947 new_binding
= ovl_cons (decl
, old
);
1948 if (flags
& PUSH_USING
)
1949 OVL_USED (new_binding
) = 1;
1952 /* NAME is not ambiguous. */
1956 set_namespace_binding (name
, current_namespace
, new_binding
);
1959 /* We only create an OVERLOAD if there was a previous binding at
1960 this level, or if decl is a template. In the former case, we
1961 need to remove the old binding and replace it with the new
1962 binding. We must also run through the NAMES on the binding
1963 level where the name was bound to update the chain. */
1965 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
1969 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
1971 d
= &TREE_CHAIN (*d
))
1973 || (TREE_CODE (*d
) == TREE_LIST
1974 && TREE_VALUE (*d
) == old
))
1976 if (TREE_CODE (*d
) == TREE_LIST
)
1977 /* Just replace the old binding with the new. */
1978 TREE_VALUE (*d
) = new_binding
;
1980 /* Build a TREE_LIST to wrap the OVERLOAD. */
1981 *d
= tree_cons (NULL_TREE
, new_binding
,
1984 /* And update the cxx_binding node. */
1985 IDENTIFIER_BINDING (name
)->value
= new_binding
;
1986 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1989 /* We should always find a previous binding in this case. */
1993 /* Install the new binding. */
1994 push_local_binding (name
, new_binding
, flags
);
1997 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2000 /* Check a non-member using-declaration. Return the name and scope
2001 being used, and the USING_DECL, or NULL_TREE on failure. */
2004 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2006 /* [namespace.udecl]
2007 A using-declaration for a class member shall be a
2008 member-declaration. */
2011 error ("%qT is not a namespace", scope
);
2014 else if (scope
== error_mark_node
)
2017 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2020 A using-declaration shall not name a template-id. */
2021 error ("a using-declaration cannot specify a template-id. "
2022 "Try %<using %D%>", name
);
2026 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2028 error ("namespace %qD not allowed in using-declaration", decl
);
2032 if (TREE_CODE (decl
) == SCOPE_REF
)
2034 /* It's a nested name with template parameter dependent scope.
2035 This can only be using-declaration for class member. */
2036 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2040 if (is_overloaded_fn (decl
))
2041 decl
= get_first_fn (decl
);
2043 gcc_assert (DECL_P (decl
));
2045 /* Make a USING_DECL. */
2046 return push_using_decl (scope
, name
);
2049 /* Process local and global using-declarations. */
2052 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2053 tree
*newval
, tree
*newtype
)
2055 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2057 *newval
= *newtype
= NULL_TREE
;
2058 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2062 if (!decls
.value
&& !decls
.type
)
2064 error ("%qD not declared", name
);
2068 /* It is impossible to overload a built-in function; any explicit
2069 declaration eliminates the built-in declaration. So, if OLDVAL
2070 is a built-in, then we can just pretend it isn't there. */
2072 && TREE_CODE (oldval
) == FUNCTION_DECL
2073 && DECL_ANTICIPATED (oldval
)
2074 && !DECL_HIDDEN_FRIEND_P (oldval
))
2077 /* Check for using functions. */
2078 if (decls
.value
&& is_overloaded_fn (decls
.value
))
2082 if (oldval
&& !is_overloaded_fn (oldval
))
2084 if (!DECL_IMPLICIT_TYPEDEF_P (oldval
))
2085 error ("%qD is already declared in this scope", name
);
2090 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2092 tree new_fn
= OVL_CURRENT (tmp
);
2094 /* [namespace.udecl]
2096 If a function declaration in namespace scope or block
2097 scope has the same name and the same parameter types as a
2098 function introduced by a using declaration the program is
2100 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2102 tree old_fn
= OVL_CURRENT (tmp1
);
2104 if (new_fn
== old_fn
)
2105 /* The function already exists in the current namespace. */
2107 else if (OVL_USED (tmp1
))
2108 continue; /* this is a using decl */
2109 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2110 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2112 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2113 || DECL_HIDDEN_FRIEND_P (old_fn
));
2115 /* There was already a non-using declaration in
2116 this scope with the same parameter types. If both
2117 are the same extern "C" functions, that's ok. */
2118 if (decls_match (new_fn
, old_fn
))
2122 error ("%qD is already declared in this scope", name
);
2128 /* If we broke out of the loop, there's no reason to add
2129 this function to the using declarations for this
2134 /* If we are adding to an existing OVERLOAD, then we no
2135 longer know the type of the set of functions. */
2136 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2137 TREE_TYPE (*newval
) = unknown_type_node
;
2138 /* Add this new function to the set. */
2139 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2140 /* If there is only one function, then we use its type. (A
2141 using-declaration naming a single function can be used in
2142 contexts where overload resolution cannot be
2144 if (TREE_CODE (*newval
) != OVERLOAD
)
2146 *newval
= ovl_cons (*newval
, NULL_TREE
);
2147 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2149 OVL_USED (*newval
) = 1;
2154 *newval
= decls
.value
;
2155 if (oldval
&& !decls_match (*newval
, oldval
))
2156 error ("%qD is already declared in this scope", name
);
2159 *newtype
= decls
.type
;
2160 if (oldtype
&& *newtype
&& !same_type_p (oldtype
, *newtype
))
2162 error ("using declaration %qD introduced ambiguous type %qT",
2168 /* Process a using-declaration at function scope. */
2171 do_local_using_decl (tree decl
, tree scope
, tree name
)
2173 tree oldval
, oldtype
, newval
, newtype
;
2174 tree orig_decl
= decl
;
2176 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2177 if (decl
== NULL_TREE
)
2180 if (building_stmt_tree ()
2181 && at_function_scope_p ())
2182 add_decl_expr (decl
);
2184 oldval
= lookup_name_innermost_nonclass_level (name
);
2185 oldtype
= lookup_type_current_level (name
);
2187 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2191 if (is_overloaded_fn (newval
))
2195 /* We only need to push declarations for those functions
2196 that were not already bound in the current level.
2197 The old value might be NULL_TREE, it might be a single
2198 function, or an OVERLOAD. */
2199 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2200 term
= OVL_FUNCTION (oldval
);
2203 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2205 push_overloaded_decl (OVL_CURRENT (fn
),
2206 PUSH_LOCAL
| PUSH_USING
,
2210 push_local_binding (name
, newval
, PUSH_USING
);
2214 push_local_binding (name
, newtype
, PUSH_USING
);
2215 set_identifier_type_value (name
, newtype
);
2218 /* Emit debug info. */
2219 if (!processing_template_decl
)
2220 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2223 /* Returns true if ROOT (a namespace, class, or function) encloses
2224 CHILD. CHILD may be either a class type or a namespace. */
2227 is_ancestor (tree root
, tree child
)
2229 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2230 || TREE_CODE (root
) == FUNCTION_DECL
2231 || CLASS_TYPE_P (root
)));
2232 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2233 || CLASS_TYPE_P (child
)));
2235 /* The global namespace encloses everything. */
2236 if (root
== global_namespace
)
2241 /* If we've run out of scopes, stop. */
2244 /* If we've reached the ROOT, it encloses CHILD. */
2247 /* Go out one level. */
2249 child
= TYPE_NAME (child
);
2250 child
= DECL_CONTEXT (child
);
2254 /* Enter the class or namespace scope indicated by T suitable for name
2255 lookup. T can be arbitrary scope, not necessary nested inside the
2256 current scope. Returns a non-null scope to pop iff pop_scope
2257 should be called later to exit this scope. */
2262 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2263 push_decl_namespace (t
);
2264 else if (CLASS_TYPE_P (t
))
2266 if (!at_class_scope_p ()
2267 || !same_type_p (current_class_type
, t
))
2268 push_nested_class (t
);
2270 /* T is the same as the current scope. There is therefore no
2271 need to re-enter the scope. Since we are not actually
2272 pushing a new scope, our caller should not call
2280 /* Leave scope pushed by push_scope. */
2285 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2286 pop_decl_namespace ();
2287 else if CLASS_TYPE_P (t
)
2288 pop_nested_class ();
2291 /* Subroutine of push_inner_scope. */
2294 push_inner_scope_r (tree outer
, tree inner
)
2299 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2302 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2304 push_inner_scope_r (outer
, prev
);
2305 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2307 struct cp_binding_level
*save_template_parm
= 0;
2308 /* Temporary take out template parameter scopes. They are saved
2309 in reversed order in save_template_parm. */
2310 while (current_binding_level
->kind
== sk_template_parms
)
2312 struct cp_binding_level
*b
= current_binding_level
;
2313 current_binding_level
= b
->level_chain
;
2314 b
->level_chain
= save_template_parm
;
2315 save_template_parm
= b
;
2318 resume_scope (NAMESPACE_LEVEL (inner
));
2319 current_namespace
= inner
;
2321 /* Restore template parameter scopes. */
2322 while (save_template_parm
)
2324 struct cp_binding_level
*b
= save_template_parm
;
2325 save_template_parm
= b
->level_chain
;
2326 b
->level_chain
= current_binding_level
;
2327 current_binding_level
= b
;
2334 /* Enter the scope INNER from current scope. INNER must be a scope
2335 nested inside current scope. This works with both name lookup and
2336 pushing name into scope. In case a template parameter scope is present,
2337 namespace is pushed under the template parameter scope according to
2338 name lookup rule in 14.6.1/6.
2340 Return the former current scope suitable for pop_inner_scope. */
2343 push_inner_scope (tree inner
)
2345 tree outer
= current_scope ();
2347 outer
= current_namespace
;
2349 push_inner_scope_r (outer
, inner
);
2353 /* Exit the current scope INNER back to scope OUTER. */
2356 pop_inner_scope (tree outer
, tree inner
)
2359 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2362 while (outer
!= inner
)
2364 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2366 struct cp_binding_level
*save_template_parm
= 0;
2367 /* Temporary take out template parameter scopes. They are saved
2368 in reversed order in save_template_parm. */
2369 while (current_binding_level
->kind
== sk_template_parms
)
2371 struct cp_binding_level
*b
= current_binding_level
;
2372 current_binding_level
= b
->level_chain
;
2373 b
->level_chain
= save_template_parm
;
2374 save_template_parm
= b
;
2379 /* Restore template parameter scopes. */
2380 while (save_template_parm
)
2382 struct cp_binding_level
*b
= save_template_parm
;
2383 save_template_parm
= b
->level_chain
;
2384 b
->level_chain
= current_binding_level
;
2385 current_binding_level
= b
;
2391 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2395 /* Do a pushlevel for class declarations. */
2398 pushlevel_class (void)
2400 if (ENABLE_SCOPE_CHECKING
)
2403 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2406 /* ...and a poplevel for class declarations. */
2409 poplevel_class (void)
2411 struct cp_binding_level
*level
= class_binding_level
;
2412 cp_class_binding
*cb
;
2416 timevar_push (TV_NAME_LOOKUP
);
2417 gcc_assert (level
!= 0);
2419 /* If we're leaving a toplevel class, cache its binding level. */
2420 if (current_class_depth
== 1)
2421 previous_class_level
= level
;
2422 for (shadowed
= level
->type_shadowed
;
2424 shadowed
= TREE_CHAIN (shadowed
))
2425 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2427 /* Remove the bindings for all of the class-level declarations. */
2428 if (level
->class_shadowed
)
2431 VEC_iterate (cp_class_binding
, level
->class_shadowed
, i
, cb
);
2433 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
.previous
;
2434 ggc_free (level
->class_shadowed
);
2435 level
->class_shadowed
= NULL
;
2438 /* Now, pop out of the binding level which we created up in the
2439 `pushlevel_class' routine. */
2440 if (ENABLE_SCOPE_CHECKING
)
2444 timevar_pop (TV_NAME_LOOKUP
);
2447 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2448 appropriate. DECL is the value to which a name has just been
2449 bound. CLASS_TYPE is the class in which the lookup occurred. */
2452 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2455 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2459 if (TREE_CODE (decl
) == OVERLOAD
)
2460 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2463 gcc_assert (DECL_P (decl
));
2464 context
= context_for_name_lookup (decl
);
2467 if (is_properly_derived_from (class_type
, context
))
2468 INHERITED_VALUE_BINDING_P (binding
) = 1;
2470 INHERITED_VALUE_BINDING_P (binding
) = 0;
2472 else if (binding
->value
== decl
)
2473 /* We only encounter a TREE_LIST when there is an ambiguity in the
2474 base classes. Such an ambiguity can be overridden by a
2475 definition in this class. */
2476 INHERITED_VALUE_BINDING_P (binding
) = 1;
2478 INHERITED_VALUE_BINDING_P (binding
) = 0;
2481 /* Make the declaration of X appear in CLASS scope. */
2484 pushdecl_class_level (tree x
)
2487 bool is_valid
= true;
2489 timevar_push (TV_NAME_LOOKUP
);
2490 /* Get the name of X. */
2491 if (TREE_CODE (x
) == OVERLOAD
)
2492 name
= DECL_NAME (get_first_fn (x
));
2494 name
= DECL_NAME (x
);
2498 is_valid
= push_class_level_binding (name
, x
);
2499 if (TREE_CODE (x
) == TYPE_DECL
)
2500 set_identifier_type_value (name
, x
);
2502 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2504 /* If X is an anonymous aggregate, all of its members are
2505 treated as if they were members of the class containing the
2506 aggregate, for naming purposes. */
2509 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= TREE_CHAIN (f
))
2511 location_t save_location
= input_location
;
2512 input_location
= DECL_SOURCE_LOCATION (f
);
2513 if (!pushdecl_class_level (f
))
2515 input_location
= save_location
;
2518 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, is_valid
);
2521 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2522 scope. If the value returned is non-NULL, and the PREVIOUS field
2523 is not set, callers must set the PREVIOUS field explicitly. */
2525 static cxx_binding
*
2526 get_class_binding (tree name
, cxx_scope
*scope
)
2531 cxx_binding
*binding
;
2533 class_type
= scope
->this_entity
;
2535 /* Get the type binding. */
2536 type_binding
= lookup_member (class_type
, name
,
2537 /*protect=*/2, /*want_type=*/true);
2538 /* Get the value binding. */
2539 value_binding
= lookup_member (class_type
, name
,
2540 /*protect=*/2, /*want_type=*/false);
2543 && (TREE_CODE (value_binding
) == TYPE_DECL
2544 || DECL_CLASS_TEMPLATE_P (value_binding
)
2545 || (TREE_CODE (value_binding
) == TREE_LIST
2546 && TREE_TYPE (value_binding
) == error_mark_node
2547 && (TREE_CODE (TREE_VALUE (value_binding
))
2549 /* We found a type binding, even when looking for a non-type
2550 binding. This means that we already processed this binding
2553 else if (value_binding
)
2555 if (TREE_CODE (value_binding
) == TREE_LIST
2556 && TREE_TYPE (value_binding
) == error_mark_node
)
2557 /* NAME is ambiguous. */
2559 else if (BASELINK_P (value_binding
))
2560 /* NAME is some overloaded functions. */
2561 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2564 /* If we found either a type binding or a value binding, create a
2565 new binding object. */
2566 if (type_binding
|| value_binding
)
2568 binding
= new_class_binding (name
,
2572 /* This is a class-scope binding, not a block-scope binding. */
2573 LOCAL_BINDING_P (binding
) = 0;
2574 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2582 /* Make the declaration(s) of X appear in CLASS scope under the name
2583 NAME. Returns true if the binding is valid. */
2586 push_class_level_binding (tree name
, tree x
)
2588 cxx_binding
*binding
;
2592 timevar_push (TV_NAME_LOOKUP
);
2593 /* The class_binding_level will be NULL if x is a template
2594 parameter name in a member template. */
2595 if (!class_binding_level
)
2596 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2598 /* Check for invalid member names. */
2599 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2600 /* We could have been passed a tree list if this is an ambiguous
2601 declaration. If so, pull the declaration out because
2602 check_template_shadow will not handle a TREE_LIST. */
2603 if (TREE_CODE (decl
) == TREE_LIST
2604 && TREE_TYPE (decl
) == error_mark_node
)
2605 decl
= TREE_VALUE (decl
);
2607 check_template_shadow (decl
);
2611 If T is the name of a class, then each of the following shall
2612 have a name different from T:
2614 -- every static data member of class T;
2616 -- every member of class T that is itself a type;
2618 -- every enumerator of every member of class T that is an
2621 -- every member of every anonymous union that is a member of
2624 (Non-static data members were also forbidden to have the same
2625 name as T until TC1.) */
2626 if ((TREE_CODE (x
) == VAR_DECL
2627 || TREE_CODE (x
) == CONST_DECL
2628 || (TREE_CODE (x
) == TYPE_DECL
2629 && !DECL_SELF_REFERENCE_P (x
))
2630 /* A data member of an anonymous union. */
2631 || (TREE_CODE (x
) == FIELD_DECL
2632 && DECL_CONTEXT (x
) != current_class_type
))
2633 && DECL_NAME (x
) == constructor_name (current_class_type
))
2635 tree scope
= context_for_name_lookup (x
);
2636 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
2638 error ("%qD has the same name as the class in which it is "
2641 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2645 /* Get the current binding for NAME in this class, if any. */
2646 binding
= IDENTIFIER_BINDING (name
);
2647 if (!binding
|| binding
->scope
!= class_binding_level
)
2649 binding
= get_class_binding (name
, class_binding_level
);
2650 /* If a new binding was created, put it at the front of the
2651 IDENTIFIER_BINDING list. */
2654 binding
->previous
= IDENTIFIER_BINDING (name
);
2655 IDENTIFIER_BINDING (name
) = binding
;
2659 /* If there is already a binding, then we may need to update the
2661 if (binding
&& binding
->value
)
2663 tree bval
= binding
->value
;
2664 tree old_decl
= NULL_TREE
;
2666 if (INHERITED_VALUE_BINDING_P (binding
))
2668 /* If the old binding was from a base class, and was for a
2669 tag name, slide it over to make room for the new binding.
2670 The old binding is still visible if explicitly qualified
2671 with a class-key. */
2672 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2673 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2675 old_decl
= binding
->type
;
2676 binding
->type
= bval
;
2677 binding
->value
= NULL_TREE
;
2678 INHERITED_VALUE_BINDING_P (binding
) = 0;
2683 /* Any inherited type declaration is hidden by the type
2684 declaration in the derived class. */
2685 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
))
2686 binding
->type
= NULL_TREE
;
2689 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2691 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2692 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2693 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
2695 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
2696 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2698 if (old_decl
&& binding
->scope
== class_binding_level
)
2701 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2702 here. This function is only used to register bindings
2703 from with the class definition itself. */
2704 INHERITED_VALUE_BINDING_P (binding
) = 0;
2705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2709 /* Note that we declared this value so that we can issue an error if
2710 this is an invalid redeclaration of a name already used for some
2712 note_name_declared_in_class (name
, decl
);
2714 /* If we didn't replace an existing binding, put the binding on the
2715 stack of bindings for the identifier, and update the shadowed
2717 if (binding
&& binding
->scope
== class_binding_level
)
2718 /* Supplement the existing binding. */
2719 ok
= supplement_binding (binding
, decl
);
2722 /* Create a new binding. */
2723 push_binding (name
, decl
, class_binding_level
);
2727 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
2730 /* Process "using SCOPE::NAME" in a class scope. Return the
2731 USING_DECL created. */
2734 do_class_using_decl (tree scope
, tree name
)
2736 /* The USING_DECL returned by this function. */
2738 /* The declaration (or declarations) name by this using
2739 declaration. NULL if we are in a template and cannot figure out
2740 what has been named. */
2742 /* True if SCOPE is a dependent type. */
2743 bool scope_dependent_p
;
2744 /* True if SCOPE::NAME is dependent. */
2745 bool name_dependent_p
;
2746 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2747 bool bases_dependent_p
;
2752 if (!scope
|| !TYPE_P (scope
))
2754 error ("using-declaration for non-member at class scope");
2758 /* Make sure the name is not invalid */
2759 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2761 error ("%<%T::%D%> names destructor", scope
, name
);
2764 if (constructor_name_p (name
, scope
))
2766 error ("%<%T::%D%> names constructor", scope
, name
);
2769 if (constructor_name_p (name
, current_class_type
))
2771 error ("%<%T::%D%> names constructor in %qT",
2772 scope
, name
, current_class_type
);
2776 scope_dependent_p
= dependent_type_p (scope
);
2777 name_dependent_p
= (scope_dependent_p
2778 || (IDENTIFIER_TYPENAME_P (name
)
2779 && dependent_type_p (TREE_TYPE (name
))));
2781 bases_dependent_p
= false;
2782 if (processing_template_decl
)
2783 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
2784 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
2786 if (dependent_type_p (TREE_TYPE (base_binfo
)))
2788 bases_dependent_p
= true;
2794 /* From [namespace.udecl]:
2796 A using-declaration used as a member-declaration shall refer to a
2797 member of a base class of the class being defined.
2799 In general, we cannot check this constraint in a template because
2800 we do not know the entire set of base classes of the current
2801 class type. However, if all of the base classes are
2802 non-dependent, then we can avoid delaying the check until
2804 if (!scope_dependent_p
&& !bases_dependent_p
)
2808 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
2809 if (b_kind
< bk_proper_base
)
2811 error_not_base_type (scope
, current_class_type
);
2815 if (!name_dependent_p
)
2817 decl
= lookup_member (binfo
, name
, 0, false);
2820 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
2824 /* The binfo from which the functions came does not matter. */
2825 if (BASELINK_P (decl
))
2826 decl
= BASELINK_FUNCTIONS (decl
);
2830 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2831 USING_DECL_DECLS (value
) = decl
;
2832 USING_DECL_SCOPE (value
) = scope
;
2833 DECL_DEPENDENT_P (value
) = !decl
;
2839 /* Return the binding value for name in scope. */
2842 namespace_binding (tree name
, tree scope
)
2844 cxx_binding
*binding
;
2847 scope
= global_namespace
;
2849 /* Unnecessary for the global namespace because it can't be an alias. */
2850 scope
= ORIGINAL_NAMESPACE (scope
);
2852 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2854 return binding
? binding
->value
: NULL_TREE
;
2857 /* Set the binding value for name in scope. */
2860 set_namespace_binding (tree name
, tree scope
, tree val
)
2864 timevar_push (TV_NAME_LOOKUP
);
2865 if (scope
== NULL_TREE
)
2866 scope
= global_namespace
;
2867 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2868 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
2871 supplement_binding (b
, val
);
2872 timevar_pop (TV_NAME_LOOKUP
);
2875 /* Set the context of a declaration to scope. Complain if we are not
2879 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
2883 /* Get rid of namespace aliases. */
2884 scope
= ORIGINAL_NAMESPACE (scope
);
2886 /* It is ok for friends to be qualified in parallel space. */
2887 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
2888 error ("declaration of %qD not in a namespace surrounding %qD",
2890 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
2892 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2893 if (scope
== current_namespace
)
2895 if (at_namespace_scope_p ())
2896 error ("explicit qualification in declaration of %qD",
2901 /* See whether this has been declared in the namespace. */
2902 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
2904 /* No old declaration at all. */
2906 if (!is_overloaded_fn (decl
))
2907 /* Don't compare non-function decls with decls_match here, since
2908 it can't check for the correct constness at this
2909 point. pushdecl will find those errors later. */
2911 /* Since decl is a function, old should contain a function decl. */
2912 if (!is_overloaded_fn (old
))
2914 fn
= OVL_CURRENT (old
);
2915 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (fn
)))
2917 /* A template can be explicitly specialized in any namespace. */
2918 if (processing_explicit_instantiation
)
2920 if (processing_template_decl
|| processing_specialization
)
2921 /* We have not yet called push_template_decl to turn a
2922 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2923 match. But, we'll check later, when we construct the
2926 /* Instantiations or specializations of templates may be declared as
2927 friends in any namespace. */
2928 if (friendp
&& DECL_USE_TEMPLATE (decl
))
2930 if (is_overloaded_fn (old
))
2932 for (; old
; old
= OVL_NEXT (old
))
2933 if (decls_match (decl
, OVL_CURRENT (old
)))
2936 else if (decls_match (decl
, old
))
2939 error ("%qD should have been declared inside %qD", decl
, scope
);
2942 /* Return the namespace where the current declaration is declared. */
2945 current_decl_namespace (void)
2948 /* If we have been pushed into a different namespace, use it. */
2949 if (decl_namespace_list
)
2950 return TREE_PURPOSE (decl_namespace_list
);
2952 if (current_class_type
)
2953 result
= decl_namespace_context (current_class_type
);
2954 else if (current_function_decl
)
2955 result
= decl_namespace_context (current_function_decl
);
2957 result
= current_namespace
;
2961 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2962 select a name that is unique to this compilation unit. */
2965 push_namespace (tree name
)
2967 push_namespace_with_attribs (name
, NULL_TREE
);
2970 /* Same, but specify attributes to apply to the namespace. The attributes
2971 only apply to the current namespace-body, not to any later extensions. */
2974 push_namespace_with_attribs (tree name
, tree attributes
)
2978 int implicit_use
= 0;
2981 timevar_push (TV_NAME_LOOKUP
);
2983 /* We should not get here if the global_namespace is not yet constructed
2984 nor if NAME designates the global namespace: The global scope is
2985 constructed elsewhere. */
2986 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
2990 /* The name of anonymous namespace is unique for the translation
2992 if (!anonymous_namespace_name
)
2993 anonymous_namespace_name
= get_file_function_name ('N');
2994 name
= anonymous_namespace_name
;
2995 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2997 /* Reopening anonymous namespace. */
3003 /* Check whether this is an extended namespace definition. */
3004 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3005 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3008 if (DECL_NAMESPACE_ALIAS (d
))
3010 error ("namespace alias %qD not allowed here, assuming %qD",
3011 d
, DECL_NAMESPACE_ALIAS (d
));
3012 d
= DECL_NAMESPACE_ALIAS (d
);
3019 /* Make a new namespace, binding the name to it. */
3020 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3021 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3022 TREE_PUBLIC (d
) = 1;
3026 /* Clear DECL_NAME for the benefit of debugging back ends. */
3027 SET_DECL_ASSEMBLER_NAME (d
, name
);
3028 DECL_NAME (d
) = NULL_TREE
;
3030 begin_scope (sk_namespace
, d
);
3033 resume_scope (NAMESPACE_LEVEL (d
));
3036 do_using_directive (d
);
3037 /* Enter the name space. */
3038 current_namespace
= d
;
3040 #ifdef HANDLE_PRAGMA_VISIBILITY
3041 /* Clear has_visibility in case a previous namespace-definition had a
3042 visibility attribute and this one doesn't. */
3043 current_binding_level
->has_visibility
= 0;
3044 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3046 tree name
= TREE_PURPOSE (d
);
3047 tree args
= TREE_VALUE (d
);
3050 if (! is_attribute_p ("visibility", name
))
3052 warning (OPT_Wattributes
, "%qs attribute directive ignored",
3053 IDENTIFIER_POINTER (name
));
3057 x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3058 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3060 warning (OPT_Wattributes
, "%qs attribute requires a single NTBS argument",
3061 IDENTIFIER_POINTER (name
));
3065 current_binding_level
->has_visibility
= 1;
3066 push_visibility (TREE_STRING_POINTER (x
));
3072 /* Anonymous namespaces default to hidden visibility. This might
3073 change once we implement export. */
3074 current_binding_level
->has_visibility
= 1;
3075 push_visibility ("hidden");
3081 timevar_pop (TV_NAME_LOOKUP
);
3084 /* Pop from the scope of the current namespace. */
3087 pop_namespace (void)
3089 gcc_assert (current_namespace
!= global_namespace
);
3090 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3091 /* The binding level is not popped, as it might be re-opened later. */
3095 /* Push into the scope of the namespace NS, even if it is deeply
3096 nested within another namespace. */
3099 push_nested_namespace (tree ns
)
3101 if (ns
== global_namespace
)
3102 push_to_top_level ();
3105 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3106 push_namespace (DECL_NAME (ns
));
3110 /* Pop back from the scope of the namespace NS, which was previously
3111 entered with push_nested_namespace. */
3114 pop_nested_namespace (tree ns
)
3116 timevar_push (TV_NAME_LOOKUP
);
3117 while (ns
!= global_namespace
)
3120 ns
= CP_DECL_CONTEXT (ns
);
3123 pop_from_top_level ();
3124 timevar_pop (TV_NAME_LOOKUP
);
3127 /* Temporarily set the namespace for the current declaration. */
3130 push_decl_namespace (tree decl
)
3132 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3133 decl
= decl_namespace_context (decl
);
3134 decl_namespace_list
= tree_cons (ORIGINAL_NAMESPACE (decl
),
3135 NULL_TREE
, decl_namespace_list
);
3138 /* [namespace.memdef]/2 */
3141 pop_decl_namespace (void)
3143 decl_namespace_list
= TREE_CHAIN (decl_namespace_list
);
3146 /* Return the namespace that is the common ancestor
3147 of two given namespaces. */
3150 namespace_ancestor (tree ns1
, tree ns2
)
3152 timevar_push (TV_NAME_LOOKUP
);
3153 if (is_ancestor (ns1
, ns2
))
3154 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ns1
);
3155 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
3156 namespace_ancestor (CP_DECL_CONTEXT (ns1
), ns2
));
3159 /* Process a namespace-alias declaration. */
3162 do_namespace_alias (tree alias
, tree
namespace)
3164 if (namespace == error_mark_node
)
3167 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL
);
3169 namespace = ORIGINAL_NAMESPACE (namespace);
3171 /* Build the alias. */
3172 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3173 DECL_NAMESPACE_ALIAS (alias
) = namespace;
3174 DECL_EXTERNAL (alias
) = 1;
3175 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3178 /* Emit debug info for namespace alias. */
3179 (*debug_hooks
->global_decl
) (alias
);
3182 /* Like pushdecl, only it places X in the current namespace,
3186 pushdecl_namespace_level (tree x
, bool is_friend
)
3188 struct cp_binding_level
*b
= current_binding_level
;
3191 timevar_push (TV_NAME_LOOKUP
);
3192 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3194 /* Now, the type_shadowed stack may screw us. Munge it so it does
3196 if (TREE_CODE (t
) == TYPE_DECL
)
3198 tree name
= DECL_NAME (t
);
3200 tree
*ptr
= (tree
*)0;
3201 for (; !global_scope_p (b
); b
= b
->level_chain
)
3203 tree shadowed
= b
->type_shadowed
;
3204 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3205 if (TREE_PURPOSE (shadowed
) == name
)
3207 ptr
= &TREE_VALUE (shadowed
);
3208 /* Can't break out of the loop here because sometimes
3209 a binding level will have duplicate bindings for
3210 PT names. It's gross, but I haven't time to fix it. */
3213 newval
= TREE_TYPE (t
);
3214 if (ptr
== (tree
*)0)
3216 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3217 up here if this is changed to an assertion. --KR */
3218 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3225 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3228 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3229 directive is not directly from the source. Also find the common
3230 ancestor and let our users know about the new namespace */
3232 add_using_namespace (tree user
, tree used
, bool indirect
)
3235 timevar_push (TV_NAME_LOOKUP
);
3236 /* Using oneself is a no-op. */
3239 timevar_pop (TV_NAME_LOOKUP
);
3242 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3243 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3244 /* Check if we already have this. */
3245 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3249 /* Promote to direct usage. */
3250 TREE_INDIRECT_USING (t
) = 0;
3251 timevar_pop (TV_NAME_LOOKUP
);
3255 /* Add used to the user's using list. */
3256 DECL_NAMESPACE_USING (user
)
3257 = tree_cons (used
, namespace_ancestor (user
, used
),
3258 DECL_NAMESPACE_USING (user
));
3260 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3262 /* Add user to the used's users list. */
3263 DECL_NAMESPACE_USERS (used
)
3264 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3266 /* Recursively add all namespaces used. */
3267 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3268 /* indirect usage */
3269 add_using_namespace (user
, TREE_PURPOSE (t
), 1);
3271 /* Tell everyone using us about the new used namespaces. */
3272 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3273 add_using_namespace (TREE_PURPOSE (t
), used
, 1);
3274 timevar_pop (TV_NAME_LOOKUP
);
3277 /* Process a using-declaration not appearing in class or local scope. */
3280 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3282 tree oldval
, oldtype
, newval
, newtype
;
3283 tree orig_decl
= decl
;
3284 cxx_binding
*binding
;
3286 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3287 if (decl
== NULL_TREE
)
3290 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3292 oldval
= binding
->value
;
3293 oldtype
= binding
->type
;
3295 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3297 /* Emit debug info. */
3298 if (!processing_template_decl
)
3299 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3301 /* Copy declarations found. */
3303 binding
->value
= newval
;
3305 binding
->type
= newtype
;
3308 /* Process a using-directive. */
3311 do_using_directive (tree
namespace)
3313 tree context
= NULL_TREE
;
3315 if (namespace == error_mark_node
)
3318 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL
);
3320 if (building_stmt_tree ())
3321 add_stmt (build_stmt (USING_STMT
, namespace));
3322 namespace = ORIGINAL_NAMESPACE (namespace);
3324 if (!toplevel_bindings_p ())
3326 push_using_directive (namespace);
3327 context
= current_scope ();
3332 add_using_namespace (current_namespace
, namespace, 0);
3333 if (current_namespace
!= global_namespace
)
3334 context
= current_namespace
;
3337 /* Emit debugging info. */
3338 if (!processing_template_decl
)
3339 (*debug_hooks
->imported_module_or_decl
) (namespace, context
);
3342 /* Deal with a using-directive seen by the parser. Currently we only
3343 handle attributes here, since they cannot appear inside a template. */
3346 parse_using_directive (tree
namespace, tree attribs
)
3350 do_using_directive (namespace);
3352 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3354 tree name
= TREE_PURPOSE (a
);
3355 if (is_attribute_p ("strong", name
))
3357 if (!toplevel_bindings_p ())
3358 error ("strong using only meaningful at namespace scope");
3359 else if (namespace != error_mark_node
)
3361 if (!is_ancestor (current_namespace
, namespace))
3362 error ("current namespace %qD does not enclose strongly used namespace %qD",
3363 current_namespace
, namespace);
3364 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3365 = tree_cons (current_namespace
, 0,
3366 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3370 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3374 /* Like pushdecl, only it places X in the global scope if appropriate.
3375 Calls cp_finish_decl to register the variable, initializing it with
3376 *INIT, if INIT is non-NULL. */
3379 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3381 timevar_push (TV_NAME_LOOKUP
);
3382 push_to_top_level ();
3383 x
= pushdecl_namespace_level (x
, is_friend
);
3385 finish_decl (x
, *init
, NULL_TREE
);
3386 pop_from_top_level ();
3387 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
3390 /* Like pushdecl, only it places X in the global scope if appropriate. */
3393 pushdecl_top_level (tree x
)
3395 return pushdecl_top_level_1 (x
, NULL
, false);
3398 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3401 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3403 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3406 /* Like pushdecl, only it places X in the global scope if
3407 appropriate. Calls cp_finish_decl to register the variable,
3408 initializing it with INIT. */
3411 pushdecl_top_level_and_finish (tree x
, tree init
)
3413 return pushdecl_top_level_1 (x
, &init
, false);
3416 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3417 duplicates. The first list becomes the tail of the result.
3419 The algorithm is O(n^2). We could get this down to O(n log n) by
3420 doing a sort on the addresses of the functions, if that becomes
3424 merge_functions (tree s1
, tree s2
)
3426 for (; s2
; s2
= OVL_NEXT (s2
))
3428 tree fn2
= OVL_CURRENT (s2
);
3431 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3433 tree fn1
= OVL_CURRENT (fns1
);
3435 /* If the function from S2 is already in S1, there is no
3436 need to add it again. For `extern "C"' functions, we
3437 might have two FUNCTION_DECLs for the same function, in
3438 different namespaces; again, we only need one of them. */
3440 || (DECL_EXTERN_C_P (fn1
) && DECL_EXTERN_C_P (fn2
)
3441 && DECL_NAME (fn1
) == DECL_NAME (fn2
)))
3445 /* If we exhausted all of the functions in S1, FN2 is new. */
3447 s1
= build_overload (fn2
, s1
);
3452 /* This should return an error not all definitions define functions.
3453 It is not an error if we find two functions with exactly the
3454 same signature, only if these are selected in overload resolution.
3455 old is the current set of bindings, new the freshly-found binding.
3456 XXX Do we want to give *all* candidates in case of ambiguity?
3457 XXX In what way should I treat extern declarations?
3458 XXX I don't want to repeat the entire duplicate_decls here */
3461 ambiguous_decl (tree name
, struct scope_binding
*old
, cxx_binding
*new,
3465 gcc_assert (old
!= NULL
);
3466 /* Copy the value. */
3469 switch (TREE_CODE (val
))
3472 /* If we expect types or namespaces, and not templates,
3473 or this is not a template class. */
3474 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3475 && !DECL_CLASS_TEMPLATE_P (val
))
3476 || hidden_name_p (val
))
3480 if (LOOKUP_NAMESPACES_ONLY (flags
) || hidden_name_p (val
))
3483 case NAMESPACE_DECL
:
3484 if (LOOKUP_TYPES_ONLY (flags
))
3488 /* Ignore built-in functions that are still anticipated. */
3489 if (LOOKUP_QUALIFIERS_ONLY (flags
) || hidden_name_p (val
))
3493 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3499 else if (val
&& val
!= old
->value
)
3501 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3502 old
->value
= merge_functions (old
->value
, val
);
3505 old
->value
= tree_cons (NULL_TREE
, old
->value
,
3506 build_tree_list (NULL_TREE
, new->value
));
3507 TREE_TYPE (old
->value
) = error_mark_node
;
3510 /* ... and copy the type. */
3512 if (LOOKUP_NAMESPACES_ONLY (flags
))
3516 else if (type
&& old
->type
!= type
)
3518 if (flags
& LOOKUP_COMPLAIN
)
3520 error ("%qD denotes an ambiguous type",name
);
3521 error ("%J first type here", TYPE_MAIN_DECL (old
->type
));
3522 error ("%J other type here", TYPE_MAIN_DECL (type
));
3527 /* Return the declarations that are members of the namespace NS. */
3530 cp_namespace_decls (tree ns
)
3532 return NAMESPACE_LEVEL (ns
)->names
;
3535 /* Combine prefer_type and namespaces_only into flags. */
3538 lookup_flags (int prefer_type
, int namespaces_only
)
3540 if (namespaces_only
)
3541 return LOOKUP_PREFER_NAMESPACES
;
3542 if (prefer_type
> 1)
3543 return LOOKUP_PREFER_TYPES
;
3544 if (prefer_type
> 0)
3545 return LOOKUP_PREFER_BOTH
;
3549 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3550 ignore it or not. Subroutine of lookup_name_real and
3551 lookup_type_scope. */
3554 qualify_lookup (tree val
, int flags
)
3556 if (val
== NULL_TREE
)
3558 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3560 if ((flags
& LOOKUP_PREFER_TYPES
)
3561 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3563 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
3568 /* Given a lookup that returned VAL, decide if we want to ignore it or
3569 not based on DECL_ANTICIPATED. */
3572 hidden_name_p (tree val
)
3575 && DECL_LANG_SPECIFIC (val
)
3576 && DECL_ANTICIPATED (val
))
3581 /* Remove any hidden friend functions from a possibly overloaded set
3585 remove_hidden_names (tree fns
)
3590 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
3592 else if (TREE_CODE (fns
) == OVERLOAD
)
3596 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3597 if (hidden_name_p (OVL_CURRENT (o
)))
3603 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3604 if (!hidden_name_p (OVL_CURRENT (o
)))
3605 n
= build_overload (OVL_CURRENT (o
), n
);
3613 /* Select the right _DECL from multiple choices. */
3616 select_decl (const struct scope_binding
*binding
, int flags
)
3619 val
= binding
->value
;
3621 timevar_push (TV_NAME_LOOKUP
);
3622 if (LOOKUP_NAMESPACES_ONLY (flags
))
3624 /* We are not interested in types. */
3625 if (val
&& (TREE_CODE (val
) == NAMESPACE_DECL
3626 || TREE_CODE (val
) == TREE_LIST
))
3627 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3628 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3631 /* If looking for a type, or if there is no non-type binding, select
3632 the value binding. */
3633 if (binding
->type
&& (!val
|| (flags
& LOOKUP_PREFER_TYPES
)))
3634 val
= binding
->type
;
3635 /* Don't return non-types if we really prefer types. */
3636 else if (val
&& LOOKUP_TYPES_ONLY (flags
)
3637 && ! DECL_DECLARES_TYPE_P (val
))
3640 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3643 /* Unscoped lookup of a global: iterate over current namespaces,
3644 considering using-directives. */
3647 unqualified_namespace_lookup (tree name
, int flags
)
3649 tree initial
= current_decl_namespace ();
3650 tree scope
= initial
;
3652 struct cp_binding_level
*level
;
3653 tree val
= NULL_TREE
;
3654 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3656 timevar_push (TV_NAME_LOOKUP
);
3658 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
3661 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3665 if (b
->value
&& hidden_name_p (b
->value
))
3666 /* Ignore anticipated built-in functions and friends. */
3669 binding
.value
= b
->value
;
3670 binding
.type
= b
->type
;
3673 /* Add all _DECLs seen through local using-directives. */
3674 for (level
= current_binding_level
;
3675 level
->kind
!= sk_namespace
;
3676 level
= level
->level_chain
)
3677 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
3679 /* Give up because of error. */
3680 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3682 /* Add all _DECLs seen through global using-directives. */
3683 /* XXX local and global using lists should work equally. */
3687 if (!lookup_using_namespace (name
, &binding
,
3688 DECL_NAMESPACE_USING (siter
),
3690 /* Give up because of error. */
3691 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3692 if (siter
== scope
) break;
3693 siter
= CP_DECL_CONTEXT (siter
);
3696 val
= select_decl (&binding
, flags
);
3697 if (scope
== global_namespace
)
3700 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3703 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3704 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3707 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3708 declaration found. If no suitable declaration can be found,
3709 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3710 neither a class-type nor a namespace a diagnostic is issued. */
3713 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
3717 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3719 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3721 flags
|= LOOKUP_COMPLAIN
;
3723 flags
|= LOOKUP_PREFER_TYPES
;
3724 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
3725 return select_decl (&binding
, flags
);
3727 else if (is_aggr_type (scope
, complain
))
3730 t
= lookup_member (scope
, name
, 2, is_type_p
);
3735 return error_mark_node
;
3738 /* Subroutine of unqualified_namespace_lookup:
3739 Add the bindings of NAME in used namespaces to VAL.
3740 We are currently looking for names in namespace SCOPE, so we
3741 look through USINGS for using-directives of namespaces
3742 which have SCOPE as a common ancestor with the current scope.
3743 Returns false on errors. */
3746 lookup_using_namespace (tree name
, struct scope_binding
*val
,
3747 tree usings
, tree scope
, int flags
)
3750 timevar_push (TV_NAME_LOOKUP
);
3751 /* Iterate over all used namespaces in current, searching for using
3752 directives of scope. */
3753 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
3754 if (TREE_VALUE (iter
) == scope
)
3756 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
3758 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
3759 /* Resolve ambiguities. */
3761 ambiguous_decl (name
, val
, val1
, flags
);
3763 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
->value
!= error_mark_node
);
3767 Accepts the NAME to lookup and its qualifying SCOPE.
3768 Returns the name/type pair found into the cxx_binding *RESULT,
3769 or false on error. */
3772 qualified_lookup_using_namespace (tree name
, tree scope
,
3773 struct scope_binding
*result
, int flags
)
3775 /* Maintain a list of namespaces visited... */
3776 tree seen
= NULL_TREE
;
3777 /* ... and a list of namespace yet to see. */
3778 tree todo
= NULL_TREE
;
3779 tree todo_maybe
= NULL_TREE
;
3781 timevar_push (TV_NAME_LOOKUP
);
3782 /* Look through namespace aliases. */
3783 scope
= ORIGINAL_NAMESPACE (scope
);
3784 while (scope
&& result
->value
!= error_mark_node
)
3786 cxx_binding
*binding
=
3787 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3788 seen
= tree_cons (scope
, NULL_TREE
, seen
);
3790 ambiguous_decl (name
, result
, binding
, flags
);
3792 /* Consider strong using directives always, and non-strong ones
3793 if we haven't found a binding yet. ??? Shouldn't we consider
3794 non-strong ones if the initial RESULT is non-NULL, but the
3795 binding in the given namespace is? */
3796 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
3797 usings
= TREE_CHAIN (usings
))
3798 /* If this was a real directive, and we have not seen it. */
3799 if (!TREE_INDIRECT_USING (usings
))
3801 /* Try to avoid queuing the same namespace more than once,
3802 the exception being when a namespace was already
3803 enqueued for todo_maybe and then a strong using is
3804 found for it. We could try to remove it from
3805 todo_maybe, but it's probably not worth the effort. */
3806 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
))
3807 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3808 && !purpose_member (TREE_PURPOSE (usings
), todo
))
3809 todo
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
, todo
);
3810 else if ((!result
->value
&& !result
->type
)
3811 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3812 && !purpose_member (TREE_PURPOSE (usings
), todo
)
3813 && !purpose_member (TREE_PURPOSE (usings
), todo_maybe
))
3814 todo_maybe
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
,
3819 scope
= TREE_PURPOSE (todo
);
3820 todo
= TREE_CHAIN (todo
);
3823 && (!result
->value
&& !result
->type
))
3825 scope
= TREE_PURPOSE (todo_maybe
);
3826 todo
= TREE_CHAIN (todo_maybe
);
3827 todo_maybe
= NULL_TREE
;
3830 scope
= NULL_TREE
; /* If there never was a todo list. */
3832 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
->value
!= error_mark_node
);
3835 /* Return the innermost non-namespace binding for NAME from a scope
3836 containing BINDING, or, if BINDING is NULL, the current scope. If
3837 CLASS_P is false, then class bindings are ignored. */
3840 outer_binding (tree name
,
3841 cxx_binding
*binding
,
3846 cxx_scope
*outer_scope
;
3850 scope
= binding
->scope
->level_chain
;
3851 outer
= binding
->previous
;
3855 scope
= current_binding_level
;
3856 outer
= IDENTIFIER_BINDING (name
);
3858 outer_scope
= outer
? outer
->scope
: NULL
;
3860 /* Because we create class bindings lazily, we might be missing a
3861 class binding for NAME. If there are any class binding levels
3862 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3863 declared, we must lookup NAME in those class scopes. */
3865 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
3867 if (scope
->kind
== sk_class
)
3869 cxx_binding
*class_binding
;
3871 class_binding
= get_class_binding (name
, scope
);
3874 /* Thread this new class-scope binding onto the
3875 IDENTIFIER_BINDING list so that future lookups
3877 class_binding
->previous
= outer
;
3879 binding
->previous
= class_binding
;
3881 IDENTIFIER_BINDING (name
) = class_binding
;
3882 return class_binding
;
3885 scope
= scope
->level_chain
;
3891 /* Return the innermost block-scope or class-scope value binding for
3892 NAME, or NULL_TREE if there is no such binding. */
3895 innermost_non_namespace_value (tree name
)
3897 cxx_binding
*binding
;
3898 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
3899 return binding
? binding
->value
: NULL_TREE
;
3902 /* Look up NAME in the current binding level and its superiors in the
3903 namespace of variables, functions and typedefs. Return a ..._DECL
3904 node of some kind representing its definition if there is only one
3905 such declaration, or return a TREE_LIST with all the overloaded
3906 definitions if there are many, or return 0 if it is undefined.
3907 Hidden name, either friend declaration or built-in function, are
3910 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3911 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3912 Otherwise we prefer non-TYPE_DECLs.
3914 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3915 BLOCK_P is false, bindings in block scopes are ignored. */
3918 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
3919 int namespaces_only
, int flags
)
3922 tree val
= NULL_TREE
;
3924 timevar_push (TV_NAME_LOOKUP
);
3925 /* Conversion operators are handled specially because ordinary
3926 unqualified name lookup will not find template conversion
3928 if (IDENTIFIER_TYPENAME_P (name
))
3930 struct cp_binding_level
*level
;
3932 for (level
= current_binding_level
;
3933 level
&& level
->kind
!= sk_namespace
;
3934 level
= level
->level_chain
)
3939 /* A conversion operator can only be declared in a class
3941 if (level
->kind
!= sk_class
)
3944 /* Lookup the conversion operator in the class. */
3945 class_type
= level
->this_entity
;
3946 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
3948 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, operators
);
3951 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3954 flags
|= lookup_flags (prefer_type
, namespaces_only
);
3956 /* First, look in non-namespace scopes. */
3958 if (current_class_type
== NULL_TREE
)
3961 if (block_p
|| !nonclass
)
3962 for (iter
= outer_binding (name
, NULL
, !nonclass
);
3964 iter
= outer_binding (name
, iter
, !nonclass
))
3968 /* Skip entities we don't want. */
3969 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
3972 /* If this is the kind of thing we're looking for, we're done. */
3973 if (qualify_lookup (iter
->value
, flags
)
3974 && !hidden_name_p (iter
->value
))
3975 binding
= iter
->value
;
3976 else if ((flags
& LOOKUP_PREFER_TYPES
)
3977 && qualify_lookup (iter
->type
, flags
)
3978 && !hidden_name_p (iter
->type
))
3979 binding
= iter
->type
;
3981 binding
= NULL_TREE
;
3990 /* Now lookup in namespace scopes. */
3992 val
= unqualified_namespace_lookup (name
, flags
);
3994 /* If we have a single function from a using decl, pull it out. */
3995 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
3996 val
= OVL_FUNCTION (val
);
3998 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4002 lookup_name_nonclass (tree name
)
4004 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4008 lookup_function_nonclass (tree name
, tree args
, bool block_p
)
4011 lookup_arg_dependent (name
,
4012 lookup_name_real (name
, 0, 1, block_p
, 0,
4018 lookup_name (tree name
)
4020 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4024 lookup_name_prefer_type (tree name
, int prefer_type
)
4026 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
4027 0, LOOKUP_COMPLAIN
);
4030 /* Look up NAME for type used in elaborated name specifier in
4031 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4032 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4033 name, more scopes are checked if cleanup or template parameter
4034 scope is encountered.
4036 Unlike lookup_name_real, we make sure that NAME is actually
4037 declared in the desired scope, not from inheritance, nor using
4038 directive. For using declaration, there is DR138 still waiting
4039 to be resolved. Hidden name coming from an earlier friend
4040 declaration is also returned.
4042 A TYPE_DECL best matching the NAME is returned. Catching error
4043 and issuing diagnostics are caller's responsibility. */
4046 lookup_type_scope (tree name
, tag_scope scope
)
4048 cxx_binding
*iter
= NULL
;
4049 tree val
= NULL_TREE
;
4051 timevar_push (TV_NAME_LOOKUP
);
4053 /* Look in non-namespace scope first. */
4054 if (current_binding_level
->kind
!= sk_namespace
)
4055 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4056 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4058 /* Check if this is the kind of thing we're looking for.
4059 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4060 base class. For ITER->VALUE, we can simply use
4061 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4064 We check ITER->TYPE before ITER->VALUE in order to handle
4065 typedef struct C {} C;
4068 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4069 && (scope
!= ts_current
4070 || LOCAL_BINDING_P (iter
)
4071 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4073 else if ((scope
!= ts_current
4074 || !INHERITED_VALUE_BINDING_P (iter
))
4075 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4082 /* Look in namespace scope. */
4085 iter
= cxx_scope_find_binding_for_name
4086 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4090 /* If this is the kind of thing we're looking for, we're done. */
4091 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4093 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4099 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4100 and template parameter scopes. */
4103 struct cp_binding_level
*b
= current_binding_level
;
4106 if (iter
->scope
== b
)
4107 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4109 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
)
4111 else if (b
->kind
== sk_class
4112 && scope
== ts_within_enclosing_non_class
)
4119 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4122 /* Similar to `lookup_name' but look only in the innermost non-class
4126 lookup_name_innermost_nonclass_level (tree name
)
4128 struct cp_binding_level
*b
;
4131 timevar_push (TV_NAME_LOOKUP
);
4132 b
= innermost_nonclass_level ();
4134 if (b
->kind
== sk_namespace
)
4136 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4138 /* extern "C" function() */
4139 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4142 else if (IDENTIFIER_BINDING (name
)
4143 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4145 cxx_binding
*binding
;
4146 binding
= IDENTIFIER_BINDING (name
);
4149 if (binding
->scope
== b
4150 && !(TREE_CODE (binding
->value
) == VAR_DECL
4151 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4152 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
->value
);
4154 if (b
->kind
== sk_cleanup
)
4161 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4164 /* Like lookup_name_innermost_nonclass_level, but for types. */
4167 lookup_type_current_level (tree name
)
4171 timevar_push (TV_NAME_LOOKUP
);
4172 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4174 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4175 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4177 struct cp_binding_level
*b
= current_binding_level
;
4180 if (purpose_member (name
, b
->type_shadowed
))
4181 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
4182 REAL_IDENTIFIER_TYPE_VALUE (name
));
4183 if (b
->kind
== sk_cleanup
)
4190 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4193 /* [basic.lookup.koenig] */
4194 /* A nonzero return value in the functions below indicates an error. */
4205 static bool arg_assoc (struct arg_lookup
*, tree
);
4206 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4207 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4208 static bool add_function (struct arg_lookup
*, tree
);
4209 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4210 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4211 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4213 /* Add a function to the lookup structure.
4214 Returns true on error. */
4217 add_function (struct arg_lookup
*k
, tree fn
)
4219 /* We used to check here to see if the function was already in the list,
4220 but that's O(n^2), which is just too expensive for function lookup.
4221 Now we deal with the occasional duplicate in joust. In doing this, we
4222 assume that the number of duplicates will be small compared to the
4223 total number of functions being compared, which should usually be the
4226 /* We must find only functions, or exactly one non-function. */
4229 else if (fn
== k
->functions
)
4231 else if (is_overloaded_fn (k
->functions
) && is_overloaded_fn (fn
))
4232 k
->functions
= build_overload (fn
, k
->functions
);
4235 tree f1
= OVL_CURRENT (k
->functions
);
4237 if (is_overloaded_fn (f1
))
4239 fn
= f1
; f1
= f2
; f2
= fn
;
4241 error ("%q+D is not a function,", f1
);
4242 error (" conflict with %q+D", f2
);
4243 error (" in call to %qD", k
->name
);
4250 /* Returns true iff CURRENT has declared itself to be an associated
4251 namespace of SCOPE via a strong using-directive (or transitive chain
4252 thereof). Both are namespaces. */
4255 is_associated_namespace (tree current
, tree scope
)
4257 tree seen
= NULL_TREE
;
4258 tree todo
= NULL_TREE
;
4262 if (scope
== current
)
4264 seen
= tree_cons (scope
, NULL_TREE
, seen
);
4265 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4266 if (!purpose_member (TREE_PURPOSE (t
), seen
))
4267 todo
= tree_cons (TREE_PURPOSE (t
), NULL_TREE
, todo
);
4270 scope
= TREE_PURPOSE (todo
);
4271 todo
= TREE_CHAIN (todo
);
4278 /* Return whether FN is a friend of an associated class of ARG. */
4281 friend_of_associated_class_p (tree arg
, tree fn
)
4287 else if (type_unknown_p (arg
))
4290 type
= TREE_TYPE (arg
);
4292 /* If TYPE is a class, the class itself and all base classes are
4293 associated classes. */
4294 if (CLASS_TYPE_P (type
))
4296 if (is_friend (type
, fn
))
4299 if (TYPE_BINFO (type
))
4301 tree binfo
, base_binfo
;
4304 for (binfo
= TYPE_BINFO (type
), i
= 0;
4305 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
4307 if (is_friend (BINFO_TYPE (base_binfo
), fn
))
4312 /* If TYPE is a class member, the class of which it is a member is
4313 an associated class. */
4314 if ((CLASS_TYPE_P (type
)
4315 || TREE_CODE (type
) == UNION_TYPE
4316 || TREE_CODE (type
) == ENUMERAL_TYPE
)
4317 && TYPE_CONTEXT (type
)
4318 && CLASS_TYPE_P (TYPE_CONTEXT (type
))
4319 && is_friend (TYPE_CONTEXT (type
), fn
))
4325 /* Add functions of a namespace to the lookup structure.
4326 Returns true on error. */
4329 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4333 if (purpose_member (scope
, k
->namespaces
))
4335 k
->namespaces
= tree_cons (scope
, NULL_TREE
, k
->namespaces
);
4337 /* Check out our super-users. */
4338 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4339 value
= TREE_CHAIN (value
))
4340 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4343 value
= namespace_binding (k
->name
, scope
);
4347 for (; value
; value
= OVL_NEXT (value
))
4349 /* We don't want to find arbitrary hidden functions via argument
4350 dependent lookup. We only want to find friends of associated
4352 if (hidden_name_p (OVL_CURRENT (value
)))
4356 for (args
= k
->args
; args
; args
= TREE_CHAIN (args
))
4357 if (friend_of_associated_class_p (TREE_VALUE (args
),
4358 OVL_CURRENT (value
)))
4364 if (add_function (k
, OVL_CURRENT (value
)))
4371 /* Adds everything associated with a template argument to the lookup
4372 structure. Returns true on error. */
4375 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4377 /* [basic.lookup.koenig]
4379 If T is a template-id, its associated namespaces and classes are
4380 ... the namespaces and classes associated with the types of the
4381 template arguments provided for template type parameters
4382 (excluding template template parameters); the namespaces in which
4383 any template template arguments are defined; and the classes in
4384 which any member templates used as template template arguments
4385 are defined. [Note: non-type template arguments do not
4386 contribute to the set of associated namespaces. ] */
4388 /* Consider first template template arguments. */
4389 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4390 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
4392 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
4394 tree ctx
= CP_DECL_CONTEXT (arg
);
4396 /* It's not a member template. */
4397 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4398 return arg_assoc_namespace (k
, ctx
);
4399 /* Otherwise, it must be member template. */
4401 return arg_assoc_class (k
, ctx
);
4403 /* It's not a template template argument, but it is a type template
4405 else if (TYPE_P (arg
))
4406 return arg_assoc_type (k
, arg
);
4407 /* It's a non-type template argument. */
4412 /* Adds everything associated with class to the lookup structure.
4413 Returns true on error. */
4416 arg_assoc_class (struct arg_lookup
*k
, tree type
)
4418 tree list
, friends
, context
;
4421 /* Backend build structures, such as __builtin_va_list, aren't
4422 affected by all this. */
4423 if (!CLASS_TYPE_P (type
))
4426 if (purpose_member (type
, k
->classes
))
4428 k
->classes
= tree_cons (type
, NULL_TREE
, k
->classes
);
4430 context
= decl_namespace_context (type
);
4431 if (arg_assoc_namespace (k
, context
))
4434 if (TYPE_BINFO (type
))
4436 /* Process baseclasses. */
4437 tree binfo
, base_binfo
;
4439 for (binfo
= TYPE_BINFO (type
), i
= 0;
4440 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4441 if (arg_assoc_class (k
, BINFO_TYPE (base_binfo
)))
4445 /* Process friends. */
4446 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
4447 list
= TREE_CHAIN (list
))
4448 if (k
->name
== FRIEND_NAME (list
))
4449 for (friends
= FRIEND_DECLS (list
); friends
;
4450 friends
= TREE_CHAIN (friends
))
4452 tree fn
= TREE_VALUE (friends
);
4454 /* Only interested in global functions with potentially hidden
4455 (i.e. unqualified) declarations. */
4456 if (CP_DECL_CONTEXT (fn
) != context
)
4458 /* Template specializations are never found by name lookup.
4459 (Templates themselves can be found, but not template
4460 specializations.) */
4461 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
4463 if (add_function (k
, fn
))
4467 /* Process template arguments. */
4468 if (CLASSTYPE_TEMPLATE_INFO (type
)
4469 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
4471 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
4472 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
4473 arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
));
4479 /* Adds everything associated with a given type.
4480 Returns 1 on error. */
4483 arg_assoc_type (struct arg_lookup
*k
, tree type
)
4485 /* As we do not get the type of non-type dependent expressions
4486 right, we can end up with such things without a type. */
4490 if (TYPE_PTRMEM_P (type
))
4492 /* Pointer to member: associate class type and value type. */
4493 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
4495 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
4497 else switch (TREE_CODE (type
))
4509 if (TYPE_PTRMEMFUNC_P (type
))
4510 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
4511 return arg_assoc_class (k
, type
);
4513 case REFERENCE_TYPE
:
4515 return arg_assoc_type (k
, TREE_TYPE (type
));
4518 return arg_assoc_namespace (k
, decl_namespace_context (type
));
4520 /* The basetype is referenced in the first arg type, so just
4523 /* Associate the parameter types. */
4524 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
4526 /* Associate the return type. */
4527 return arg_assoc_type (k
, TREE_TYPE (type
));
4528 case TEMPLATE_TYPE_PARM
:
4529 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4534 gcc_assert (type
== unknown_type_node
);
4542 /* Adds everything associated with arguments. Returns true on error. */
4545 arg_assoc_args (struct arg_lookup
*k
, tree args
)
4547 for (; args
; args
= TREE_CHAIN (args
))
4548 if (arg_assoc (k
, TREE_VALUE (args
)))
4553 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4556 arg_assoc (struct arg_lookup
*k
, tree n
)
4558 if (n
== error_mark_node
)
4562 return arg_assoc_type (k
, n
);
4564 if (! type_unknown_p (n
))
4565 return arg_assoc_type (k
, TREE_TYPE (n
));
4567 if (TREE_CODE (n
) == ADDR_EXPR
)
4568 n
= TREE_OPERAND (n
, 0);
4569 if (TREE_CODE (n
) == COMPONENT_REF
)
4570 n
= TREE_OPERAND (n
, 1);
4571 if (TREE_CODE (n
) == OFFSET_REF
)
4572 n
= TREE_OPERAND (n
, 1);
4573 while (TREE_CODE (n
) == TREE_LIST
)
4575 if (TREE_CODE (n
) == BASELINK
)
4576 n
= BASELINK_FUNCTIONS (n
);
4578 if (TREE_CODE (n
) == FUNCTION_DECL
)
4579 return arg_assoc_type (k
, TREE_TYPE (n
));
4580 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
4582 /* [basic.lookup.koenig]
4584 If T is a template-id, its associated namespaces and classes
4585 are the namespace in which the template is defined; for
4586 member templates, the member template's class... */
4587 tree
template = TREE_OPERAND (n
, 0);
4588 tree args
= TREE_OPERAND (n
, 1);
4592 if (TREE_CODE (template) == COMPONENT_REF
)
4593 template = TREE_OPERAND (template, 1);
4595 /* First, the template. There may actually be more than one if
4596 this is an overloaded function template. But, in that case,
4597 we only need the first; all the functions will be in the same
4599 template = OVL_CURRENT (template);
4601 ctx
= CP_DECL_CONTEXT (template);
4603 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4605 if (arg_assoc_namespace (k
, ctx
) == 1)
4608 /* It must be a member template. */
4609 else if (arg_assoc_class (k
, ctx
) == 1)
4612 /* Now the arguments. */
4614 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
4615 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
4618 else if (TREE_CODE (n
) == OVERLOAD
)
4620 for (; n
; n
= OVL_CHAIN (n
))
4621 if (arg_assoc_type (k
, TREE_TYPE (OVL_FUNCTION (n
))))
4628 /* Performs Koenig lookup depending on arguments, where fns
4629 are the functions found in normal lookup. */
4632 lookup_arg_dependent (tree name
, tree fns
, tree args
)
4634 struct arg_lookup k
;
4636 timevar_push (TV_NAME_LOOKUP
);
4638 /* Remove any hidden friend functions from the list of functions
4639 found so far. They will be added back by arg_assoc_class as
4641 fns
= remove_hidden_names (fns
);
4646 k
.classes
= NULL_TREE
;
4648 /* We previously performed an optimization here by setting
4649 NAMESPACES to the current namespace when it was safe. However, DR
4650 164 says that namespaces that were already searched in the first
4651 stage of template processing are searched again (potentially
4652 picking up later definitions) in the second stage. */
4653 k
.namespaces
= NULL_TREE
;
4655 arg_assoc_args (&k
, args
);
4656 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, k
.functions
);
4659 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4660 changed (i.e. there was already a directive), or the fresh
4661 TREE_LIST otherwise. */
4664 push_using_directive (tree used
)
4666 tree ud
= current_binding_level
->using_directives
;
4667 tree iter
, ancestor
;
4669 timevar_push (TV_NAME_LOOKUP
);
4670 /* Check if we already have this. */
4671 if (purpose_member (used
, ud
) != NULL_TREE
)
4672 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4674 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4675 ud
= current_binding_level
->using_directives
;
4676 ud
= tree_cons (used
, ancestor
, ud
);
4677 current_binding_level
->using_directives
= ud
;
4679 /* Recursively add all namespaces used. */
4680 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4681 push_using_directive (TREE_PURPOSE (iter
));
4683 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ud
);
4686 /* The type TYPE is being declared. If it is a class template, or a
4687 specialization of a class template, do any processing required and
4688 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4689 being declared a friend. B is the binding level at which this TYPE
4692 Returns the TYPE_DECL for TYPE, which may have been altered by this
4696 maybe_process_template_type_declaration (tree type
, int is_friend
,
4699 tree decl
= TYPE_NAME (type
);
4701 if (processing_template_parmlist
)
4702 /* You can't declare a new template type in a template parameter
4703 list. But, you can declare a non-template type:
4705 template <class A*> struct S;
4707 is a forward-declaration of `A'. */
4709 else if (b
->kind
== sk_namespace
4710 && current_binding_level
->kind
!= sk_namespace
)
4711 /* If this new type is being injected into a containing scope,
4712 then it's not a template type. */
4716 gcc_assert (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ENUMERAL_TYPE
);
4718 if (processing_template_decl
)
4720 /* This may change after the call to
4721 push_template_decl_real, but we want the original value. */
4722 tree name
= DECL_NAME (decl
);
4724 decl
= push_template_decl_real (decl
, is_friend
);
4725 /* If the current binding level is the binding level for the
4726 template parameters (see the comment in
4727 begin_template_parm_list) and the enclosing level is a class
4728 scope, and we're not looking at a friend, push the
4729 declaration of the member class into the class scope. In the
4730 friend case, push_template_decl will already have put the
4731 friend into global scope, if appropriate. */
4732 if (TREE_CODE (type
) != ENUMERAL_TYPE
4733 && !is_friend
&& b
->kind
== sk_template_parms
4734 && b
->level_chain
->kind
== sk_class
)
4736 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
4738 if (!COMPLETE_TYPE_P (current_class_type
))
4740 maybe_add_class_template_decl_list (current_class_type
,
4741 type
, /*friend_p=*/0);
4742 /* Put this UTD in the table of UTDs for the class. */
4743 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
4744 CLASSTYPE_NESTED_UTDS (current_class_type
) =
4745 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4747 binding_table_insert
4748 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
4757 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4758 that the NAME is a class template, the tag is processed but not pushed.
4760 The pushed scope depend on the SCOPE parameter:
4761 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4763 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4764 non-template-parameter scope. This case is needed for forward
4766 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4767 TS_GLOBAL case except that names within template-parameter scopes
4768 are not pushed at all.
4770 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4773 pushtag (tree name
, tree type
, tag_scope scope
)
4775 struct cp_binding_level
*b
;
4778 timevar_push (TV_NAME_LOOKUP
);
4779 b
= current_binding_level
;
4780 while (/* Cleanup scopes are not scopes from the point of view of
4782 b
->kind
== sk_cleanup
4783 /* Neither are the scopes used to hold template parameters
4784 for an explicit specialization. For an ordinary template
4785 declaration, these scopes are not scopes from the point of
4786 view of the language. */
4787 || (b
->kind
== sk_template_parms
4788 && (b
->explicit_spec_p
|| scope
== ts_global
))
4789 || (b
->kind
== sk_class
4790 && (scope
!= ts_current
4791 /* We may be defining a new type in the initializer
4792 of a static member variable. We allow this when
4793 not pedantic, and it is particularly useful for
4794 type punning via an anonymous union. */
4795 || COMPLETE_TYPE_P (b
->this_entity
))))
4798 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
4800 /* Do C++ gratuitous typedefing. */
4801 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
4805 tree context
= TYPE_CONTEXT (type
);
4809 tree cs
= current_scope ();
4811 if (scope
== ts_current
)
4813 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
4814 /* When declaring a friend class of a local class, we want
4815 to inject the newly named class into the scope
4816 containing the local class, not the namespace
4818 context
= decl_function_context (get_type_decl (cs
));
4821 context
= current_namespace
;
4823 if (b
->kind
== sk_class
4824 || (b
->kind
== sk_template_parms
4825 && b
->level_chain
->kind
== sk_class
))
4828 if (current_lang_name
== lang_name_java
)
4829 TYPE_FOR_JAVA (type
) = 1;
4831 tdef
= create_implicit_typedef (name
, type
);
4832 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
4833 if (scope
== ts_within_enclosing_non_class
)
4835 /* This is a friend. Make this TYPE_DECL node hidden from
4836 ordinary name lookup. Its corresponding TEMPLATE_DECL
4837 will be marked in push_template_decl_real. */
4838 retrofit_lang_decl (tdef
);
4839 DECL_ANTICIPATED (tdef
) = 1;
4840 DECL_FRIEND_P (tdef
) = 1;
4843 decl
= maybe_process_template_type_declaration
4844 (type
, scope
== ts_within_enclosing_non_class
, b
);
4845 if (decl
== error_mark_node
)
4846 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
4849 set_identifier_type_value_with_scope (name
, tdef
, b
);
4851 if (b
->kind
== sk_class
)
4853 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4854 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4855 class. But if it's a member template class, we want
4856 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4858 finish_member_declaration (decl
);
4860 pushdecl_class_level (decl
);
4862 else if (b
->kind
!= sk_template_parms
)
4863 decl
= pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
4865 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
4867 /* If this is a local class, keep track of it. We need this
4868 information for name-mangling, and so that it is possible to
4869 find all function definitions in a translation unit in a
4870 convenient way. (It's otherwise tricky to find a member
4871 function definition it's only pointed to from within a local
4873 if (TYPE_CONTEXT (type
)
4874 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
4875 VEC_safe_push (tree
, gc
, local_classes
, type
);
4877 if (b
->kind
== sk_class
4878 && !COMPLETE_TYPE_P (current_class_type
))
4880 maybe_add_class_template_decl_list (current_class_type
,
4881 type
, /*friend_p=*/0);
4883 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
4884 CLASSTYPE_NESTED_UTDS (current_class_type
)
4885 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4887 binding_table_insert
4888 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
4891 decl
= TYPE_NAME (type
);
4892 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
4893 TYPE_STUB_DECL (type
) = decl
;
4895 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, type
);
4898 /* Subroutines for reverting temporarily to top-level for instantiation
4899 of templates and such. We actually need to clear out the class- and
4900 local-value slots of all identifiers, so that only the global values
4901 are at all visible. Simply setting current_binding_level to the global
4902 scope isn't enough, because more binding levels may be pushed. */
4903 struct saved_scope
*scope_chain
;
4905 /* If ID has not already been marked, add an appropriate binding to
4909 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
4911 cxx_saved_binding
*saved
;
4913 if (!id
|| !IDENTIFIER_BINDING (id
))
4916 if (IDENTIFIER_MARKED (id
))
4919 IDENTIFIER_MARKED (id
) = 1;
4921 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
4922 saved
->identifier
= id
;
4923 saved
->binding
= IDENTIFIER_BINDING (id
);
4924 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
4925 IDENTIFIER_BINDING (id
) = NULL
;
4929 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
4933 timevar_push (TV_NAME_LOOKUP
);
4934 for (t
= names
; t
; t
= TREE_CHAIN (t
))
4938 if (TREE_CODE (t
) == TREE_LIST
)
4939 id
= TREE_PURPOSE (t
);
4943 store_binding (id
, old_bindings
);
4945 timevar_pop (TV_NAME_LOOKUP
);
4948 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4949 objects, rather than a TREE_LIST. */
4952 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
4953 VEC(cxx_saved_binding
,gc
) **old_bindings
)
4956 cp_class_binding
*cb
;
4958 timevar_push (TV_NAME_LOOKUP
);
4959 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
4960 store_binding (cb
->identifier
, old_bindings
);
4961 timevar_pop (TV_NAME_LOOKUP
);
4965 push_to_top_level (void)
4967 struct saved_scope
*s
;
4968 struct cp_binding_level
*b
;
4969 cxx_saved_binding
*sb
;
4973 timevar_push (TV_NAME_LOOKUP
);
4974 s
= GGC_CNEW (struct saved_scope
);
4976 b
= scope_chain
? current_binding_level
: 0;
4978 /* If we're in the middle of some function, save our state. */
4982 push_function_context_to (NULL_TREE
);
4987 if (scope_chain
&& previous_class_level
)
4988 store_class_bindings (previous_class_level
->class_shadowed
,
4991 /* Have to include the global scope, because class-scope decls
4992 aren't listed anywhere useful. */
4993 for (; b
; b
= b
->level_chain
)
4997 /* Template IDs are inserted into the global level. If they were
4998 inserted into namespace level, finish_file wouldn't find them
4999 when doing pending instantiations. Therefore, don't stop at
5000 namespace level, but continue until :: . */
5001 if (global_scope_p (b
))
5004 store_bindings (b
->names
, &s
->old_bindings
);
5005 /* We also need to check class_shadowed to save class-level type
5006 bindings, since pushclass doesn't fill in b->names. */
5007 if (b
->kind
== sk_class
)
5008 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
5010 /* Unwind type-value slots back to top level. */
5011 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
5012 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
5015 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, sb
); ++i
)
5016 IDENTIFIER_MARKED (sb
->identifier
) = 0;
5018 s
->prev
= scope_chain
;
5020 s
->need_pop_function_context
= need_pop
;
5021 s
->function_decl
= current_function_decl
;
5022 s
->skip_evaluation
= skip_evaluation
;
5025 current_function_decl
= NULL_TREE
;
5026 current_lang_base
= VEC_alloc (tree
, gc
, 10);
5027 current_lang_name
= lang_name_cplusplus
;
5028 current_namespace
= global_namespace
;
5029 push_class_stack ();
5030 skip_evaluation
= 0;
5031 timevar_pop (TV_NAME_LOOKUP
);
5035 pop_from_top_level (void)
5037 struct saved_scope
*s
= scope_chain
;
5038 cxx_saved_binding
*saved
;
5041 timevar_push (TV_NAME_LOOKUP
);
5042 /* Clear out class-level bindings cache. */
5043 if (previous_class_level
)
5044 invalidate_class_lookup_cache ();
5047 current_lang_base
= 0;
5049 scope_chain
= s
->prev
;
5050 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, saved
); ++i
)
5052 tree id
= saved
->identifier
;
5054 IDENTIFIER_BINDING (id
) = saved
->binding
;
5055 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
5058 /* If we were in the middle of compiling a function, restore our
5060 if (s
->need_pop_function_context
)
5061 pop_function_context_from (NULL_TREE
);
5062 current_function_decl
= s
->function_decl
;
5063 skip_evaluation
= s
->skip_evaluation
;
5064 timevar_pop (TV_NAME_LOOKUP
);
5067 /* Pop off extraneous binding levels left over due to syntax errors.
5069 We don't pop past namespaces, as they might be valid. */
5072 pop_everything (void)
5074 if (ENABLE_SCOPE_CHECKING
)
5075 verbatim ("XXX entering pop_everything ()\n");
5076 while (!toplevel_bindings_p ())
5078 if (current_binding_level
->kind
== sk_class
)
5079 pop_nested_class ();
5083 if (ENABLE_SCOPE_CHECKING
)
5084 verbatim ("XXX leaving pop_everything ()\n");
5087 /* Emit debugging information for using declarations and directives.
5088 If input tree is overloaded fn then emit debug info for all
5092 cp_emit_debug_info_for_using (tree t
, tree context
)
5094 /* Don't try to emit any debug information if we have errors. */
5095 if (sorrycount
|| errorcount
)
5098 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5099 of a builtin function. */
5100 if (TREE_CODE (t
) == FUNCTION_DECL
5101 && DECL_EXTERNAL (t
)
5102 && DECL_BUILT_IN (t
))
5105 /* Do not supply context to imported_module_or_decl, if
5106 it is a global namespace. */
5107 if (context
== global_namespace
)
5108 context
= NULL_TREE
;
5111 t
= BASELINK_FUNCTIONS (t
);
5113 /* FIXME: Handle TEMPLATE_DECLs. */
5114 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
5115 if (TREE_CODE (t
) != TEMPLATE_DECL
)
5116 (*debug_hooks
->imported_module_or_decl
) (t
, context
);
5119 #include "gt-cp-name-lookup.h"