1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
31 #include "diagnostic-core.h"
34 #include "c-family/c-pragma.h"
36 #include "pointer-set.h"
38 /* The bindings for a particular name in a particular scope. */
40 struct scope_binding
{
44 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
46 static cp_binding_level
*innermost_nonclass_level (void);
47 static cxx_binding
*binding_for_name (cp_binding_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
);
55 static tree
lookup_extern_c_fun_in_all_ns (tree
);
57 /* The :: namespace. */
59 tree global_namespace
;
61 /* The name of the anonymous namespace, throughout this translation
63 static GTY(()) tree anonymous_namespace_name
;
65 /* Initialize anonymous_namespace_name if necessary, and return it. */
68 get_anonymous_namespace_name (void)
70 if (!anonymous_namespace_name
)
72 /* The anonymous namespace has to have a unique name
73 if typeinfo objects are being compared by name. */
74 if (! flag_weak
|| ! SUPPORTS_ONE_ONLY
)
75 anonymous_namespace_name
= get_file_function_name ("N");
77 /* The demangler expects anonymous namespaces to be called
78 something starting with '_GLOBAL__N_'. */
79 anonymous_namespace_name
= get_identifier ("_GLOBAL__N_1");
81 return anonymous_namespace_name
;
84 /* Compute the chain index of a binding_entry given the HASH value of its
85 name and the total COUNT of chains. COUNT is assumed to be a power
88 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
90 /* A free list of "binding_entry"s awaiting for re-use. */
92 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
94 /* Create a binding_entry object for (NAME, TYPE). */
96 static inline binding_entry
97 binding_entry_make (tree name
, tree type
)
101 if (free_binding_entry
)
103 entry
= free_binding_entry
;
104 free_binding_entry
= entry
->chain
;
107 entry
= ggc_alloc_binding_entry_s ();
116 /* Put ENTRY back on the free list. */
119 binding_entry_free (binding_entry entry
)
123 entry
->chain
= free_binding_entry
;
124 free_binding_entry
= entry
;
128 /* The datatype used to implement the mapping from names to types at
130 struct GTY(()) binding_table_s
{
131 /* Array of chains of "binding_entry"s */
132 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
134 /* The number of chains in this table. This is the length of the
135 member "chain" considered as an array. */
138 /* Number of "binding_entry"s in this table. */
142 /* Construct TABLE with an initial CHAIN_COUNT. */
145 binding_table_construct (binding_table table
, size_t chain_count
)
147 table
->chain_count
= chain_count
;
148 table
->entry_count
= 0;
149 table
->chain
= ggc_alloc_cleared_vec_binding_entry (table
->chain_count
);
152 /* Make TABLE's entries ready for reuse. */
155 binding_table_free (binding_table table
)
163 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
165 binding_entry temp
= table
->chain
[i
];
168 binding_entry entry
= temp
;
170 binding_entry_free (entry
);
172 table
->chain
[i
] = NULL
;
174 table
->entry_count
= 0;
178 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
180 static inline binding_table
181 binding_table_new (size_t chain_count
)
183 binding_table table
= ggc_alloc_binding_table_s ();
185 binding_table_construct (table
, chain_count
);
189 /* Expand TABLE to twice its current chain_count. */
192 binding_table_expand (binding_table table
)
194 const size_t old_chain_count
= table
->chain_count
;
195 const size_t old_entry_count
= table
->entry_count
;
196 const size_t new_chain_count
= 2 * old_chain_count
;
197 binding_entry
*old_chains
= table
->chain
;
200 binding_table_construct (table
, new_chain_count
);
201 for (i
= 0; i
< old_chain_count
; ++i
)
203 binding_entry entry
= old_chains
[i
];
204 for (; entry
!= NULL
; entry
= old_chains
[i
])
206 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
207 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
209 old_chains
[i
] = entry
->chain
;
210 entry
->chain
= table
->chain
[j
];
211 table
->chain
[j
] = entry
;
214 table
->entry_count
= old_entry_count
;
217 /* Insert a binding for NAME to TYPE into TABLE. */
220 binding_table_insert (binding_table table
, tree name
, tree type
)
222 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
223 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
224 binding_entry entry
= binding_entry_make (name
, type
);
226 entry
->chain
= table
->chain
[i
];
227 table
->chain
[i
] = entry
;
228 ++table
->entry_count
;
230 if (3 * table
->chain_count
< 5 * table
->entry_count
)
231 binding_table_expand (table
);
234 /* Return the binding_entry, if any, that maps NAME. */
237 binding_table_find (binding_table table
, tree name
)
239 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
240 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
242 while (entry
!= NULL
&& entry
->name
!= name
)
243 entry
= entry
->chain
;
248 /* Apply PROC -- with DATA -- to all entries in TABLE. */
251 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
253 const size_t chain_count
= table
->chain_count
;
256 for (i
= 0; i
< chain_count
; ++i
)
258 binding_entry entry
= table
->chain
[i
];
259 for (; entry
!= NULL
; entry
= entry
->chain
)
264 #ifndef ENABLE_SCOPE_CHECKING
265 # define ENABLE_SCOPE_CHECKING 0
267 # define ENABLE_SCOPE_CHECKING 1
270 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
272 static GTY((deletable
)) cxx_binding
*free_bindings
;
274 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
278 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
280 binding
->value
= value
;
281 binding
->type
= type
;
282 binding
->previous
= NULL
;
285 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
288 cxx_binding_make (tree value
, tree type
)
290 cxx_binding
*binding
;
293 binding
= free_bindings
;
294 free_bindings
= binding
->previous
;
297 binding
= ggc_alloc_cxx_binding ();
299 cxx_binding_init (binding
, value
, type
);
304 /* Put BINDING back on the free list. */
307 cxx_binding_free (cxx_binding
*binding
)
309 binding
->scope
= NULL
;
310 binding
->previous
= free_bindings
;
311 free_bindings
= binding
;
314 /* Create a new binding for NAME (with the indicated VALUE and TYPE
315 bindings) in the class scope indicated by SCOPE. */
318 new_class_binding (tree name
, tree value
, tree type
, cp_binding_level
*scope
)
320 cp_class_binding
*cb
;
321 cxx_binding
*binding
;
323 cb
= VEC_safe_push (cp_class_binding
, gc
, scope
->class_shadowed
, NULL
);
325 cb
->identifier
= name
;
326 cb
->base
= binding
= cxx_binding_make (value
, type
);
327 binding
->scope
= scope
;
331 /* Make DECL the innermost binding for ID. The LEVEL is the binding
332 level at which this declaration is being bound. */
335 push_binding (tree id
, tree decl
, cp_binding_level
* level
)
337 cxx_binding
*binding
;
339 if (level
!= class_binding_level
)
341 binding
= cxx_binding_make (decl
, NULL_TREE
);
342 binding
->scope
= level
;
345 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
347 /* Now, fill in the binding information. */
348 binding
->previous
= IDENTIFIER_BINDING (id
);
349 INHERITED_VALUE_BINDING_P (binding
) = 0;
350 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
352 /* And put it on the front of the list of bindings for ID. */
353 IDENTIFIER_BINDING (id
) = binding
;
356 /* Remove the binding for DECL which should be the innermost binding
360 pop_binding (tree id
, tree decl
)
362 cxx_binding
*binding
;
365 /* It's easiest to write the loops that call this function without
366 checking whether or not the entities involved have names. We
367 get here for such an entity. */
370 /* Get the innermost binding for ID. */
371 binding
= IDENTIFIER_BINDING (id
);
373 /* The name should be bound. */
374 gcc_assert (binding
!= NULL
);
376 /* The DECL will be either the ordinary binding or the type
377 binding for this identifier. Remove that binding. */
378 if (binding
->value
== decl
)
379 binding
->value
= NULL_TREE
;
382 gcc_assert (binding
->type
== decl
);
383 binding
->type
= NULL_TREE
;
386 if (!binding
->value
&& !binding
->type
)
388 /* We're completely done with the innermost binding for this
389 identifier. Unhook it from the list of bindings. */
390 IDENTIFIER_BINDING (id
) = binding
->previous
;
392 /* Add it to the free list. */
393 cxx_binding_free (binding
);
397 /* BINDING records an existing declaration for a name in the current scope.
398 But, DECL is another declaration for that same identifier in the
399 same scope. This is the `struct stat' hack whereby a non-typedef
400 class name or enum-name can be bound at the same level as some other
404 A class name (9.1) or enumeration name (7.2) can be hidden by the
405 name of an object, function, or enumerator declared in the same scope.
406 If a class or enumeration name and an object, function, or enumerator
407 are declared in the same scope (in any order) with the same name, the
408 class or enumeration name is hidden wherever the object, function, or
409 enumerator name is visible.
411 It's the responsibility of the caller to check that
412 inserting this name is valid here. Returns nonzero if the new binding
416 supplement_binding_1 (cxx_binding
*binding
, tree decl
)
418 tree bval
= binding
->value
;
421 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
422 /* The new name is the type name. */
423 binding
->type
= decl
;
424 else if (/* BVAL is null when push_class_level_binding moves an
425 inherited type-binding out of the way to make room for a
426 new value binding. */
428 /* BVAL is error_mark_node when DECL's name has been used
429 in a non-class scope prior declaration. In that case,
430 we should have already issued a diagnostic; for graceful
431 error recovery purpose, pretend this was the intended
432 declaration for that name. */
433 || bval
== error_mark_node
434 /* If BVAL is anticipated but has not yet been declared,
435 pretend it is not there at all. */
436 || (TREE_CODE (bval
) == FUNCTION_DECL
437 && DECL_ANTICIPATED (bval
)
438 && !DECL_HIDDEN_FRIEND_P (bval
)))
439 binding
->value
= decl
;
440 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
441 && (TREE_CODE (decl
) != TYPE_DECL
442 || same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))))
444 /* The old binding was a type name. It was placed in
445 VALUE field because it was thought, at the point it was
446 declared, to be the only entity with such a name. Move the
447 type name into the type slot; it is now hidden by the new
449 binding
->type
= bval
;
450 binding
->value
= decl
;
451 binding
->value_is_inherited
= false;
453 else if (TREE_CODE (bval
) == TYPE_DECL
454 && TREE_CODE (decl
) == TYPE_DECL
455 && DECL_NAME (decl
) == DECL_NAME (bval
)
456 && binding
->scope
->kind
!= sk_class
457 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
458 /* If either type involves template parameters, we must
459 wait until instantiation. */
460 || uses_template_parms (TREE_TYPE (decl
))
461 || uses_template_parms (TREE_TYPE (bval
))))
462 /* We have two typedef-names, both naming the same type to have
463 the same name. In general, this is OK because of:
467 In a given scope, a typedef specifier can be used to redefine
468 the name of any type declared in that scope to refer to the
469 type to which it already refers.
471 However, in class scopes, this rule does not apply due to the
472 stricter language in [class.mem] prohibiting redeclarations of
475 /* There can be two block-scope declarations of the same variable,
476 so long as they are `extern' declarations. However, there cannot
477 be two declarations of the same static data member:
481 A member shall not be declared twice in the
482 member-specification. */
483 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
484 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
485 && !DECL_CLASS_SCOPE_P (decl
))
487 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
490 else if (TREE_CODE (decl
) == NAMESPACE_DECL
491 && TREE_CODE (bval
) == NAMESPACE_DECL
492 && DECL_NAMESPACE_ALIAS (decl
)
493 && DECL_NAMESPACE_ALIAS (bval
)
494 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
497 In a declarative region, a namespace-alias-definition can be
498 used to redefine a namespace-alias declared in that declarative
499 region to refer only to the namespace to which it already
504 error ("declaration of %q#D", decl
);
505 error ("conflicts with previous declaration %q+#D", bval
);
512 /* Wrapper for supplement_binding_1. */
515 supplement_binding (cxx_binding
*binding
, tree decl
)
518 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
519 ret
= supplement_binding_1 (binding
, decl
);
520 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
524 /* Add DECL to the list of things declared in B. */
527 add_decl_to_level (tree decl
, cp_binding_level
*b
)
529 /* We used to record virtual tables as if they were ordinary
530 variables, but no longer do so. */
531 gcc_assert (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
)));
533 if (TREE_CODE (decl
) == NAMESPACE_DECL
534 && !DECL_NAMESPACE_ALIAS (decl
))
536 DECL_CHAIN (decl
) = b
->namespaces
;
537 b
->namespaces
= decl
;
541 /* We build up the list in reverse order, and reverse it later if
543 TREE_CHAIN (decl
) = b
->names
;
546 /* If appropriate, add decl to separate list of statics. We
547 include extern variables because they might turn out to be
548 static later. It's OK for this list to contain a few false
550 if (b
->kind
== sk_namespace
)
551 if ((TREE_CODE (decl
) == VAR_DECL
552 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
553 || (TREE_CODE (decl
) == FUNCTION_DECL
554 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
555 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
559 /* Record a decl-node X as belonging to the current lexical scope.
560 Check for errors (such as an incompatible declaration for the same
561 name already seen in the same scope). IS_FRIEND is true if X is
562 declared as a friend.
564 Returns either X or an old decl for the same name.
565 If an old decl is returned, it may have been smashed
566 to agree with what X says. */
569 pushdecl_maybe_friend_1 (tree x
, bool is_friend
)
573 int need_new_binding
;
575 if (x
== error_mark_node
)
576 return error_mark_node
;
578 need_new_binding
= 1;
580 if (DECL_TEMPLATE_PARM_P (x
))
581 /* Template parameters have no context; they are not X::T even
582 when declared within a class or namespace. */
586 if (current_function_decl
&& x
!= current_function_decl
587 /* A local declaration for a function doesn't constitute
589 && TREE_CODE (x
) != FUNCTION_DECL
590 /* A local declaration for an `extern' variable is in the
591 scope of the current namespace, not the current
593 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
594 /* When parsing the parameter list of a function declarator,
595 don't set DECL_CONTEXT to an enclosing function. When we
596 push the PARM_DECLs in order to process the function body,
597 current_binding_level->this_entity will be set. */
598 && !(TREE_CODE (x
) == PARM_DECL
599 && current_binding_level
->kind
== sk_function_parms
600 && current_binding_level
->this_entity
== NULL
)
601 && !DECL_CONTEXT (x
))
602 DECL_CONTEXT (x
) = current_function_decl
;
604 /* If this is the declaration for a namespace-scope function,
605 but the declaration itself is in a local scope, mark the
607 if (TREE_CODE (x
) == FUNCTION_DECL
608 && DECL_NAMESPACE_SCOPE_P (x
)
609 && current_function_decl
610 && x
!= current_function_decl
)
611 DECL_LOCAL_FUNCTION_P (x
) = 1;
614 name
= DECL_NAME (x
);
617 int different_binding_level
= 0;
619 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
620 name
= TREE_OPERAND (name
, 0);
622 /* In case this decl was explicitly namespace-qualified, look it
623 up in its namespace context. */
624 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
625 t
= namespace_binding (name
, DECL_CONTEXT (x
));
627 t
= lookup_name_innermost_nonclass_level (name
);
629 /* [basic.link] If there is a visible declaration of an entity
630 with linkage having the same name and type, ignoring entities
631 declared outside the innermost enclosing namespace scope, the
632 block scope declaration declares that same entity and
633 receives the linkage of the previous declaration. */
634 if (! t
&& current_function_decl
&& x
!= current_function_decl
635 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
636 && DECL_EXTERNAL (x
))
638 /* Look in block scope. */
639 t
= innermost_non_namespace_value (name
);
640 /* Or in the innermost namespace. */
642 t
= namespace_binding (name
, DECL_CONTEXT (x
));
643 /* Does it have linkage? Note that if this isn't a DECL, it's an
644 OVERLOAD, which is OK. */
645 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
648 different_binding_level
= 1;
651 /* If we are declaring a function, and the result of name-lookup
652 was an OVERLOAD, look for an overloaded instance that is
653 actually the same as the function we are declaring. (If
654 there is one, we have to merge our declaration with the
655 previous declaration.) */
656 if (t
&& TREE_CODE (t
) == OVERLOAD
)
660 if (TREE_CODE (x
) == FUNCTION_DECL
)
661 for (match
= t
; match
; match
= OVL_NEXT (match
))
663 if (decls_match (OVL_CURRENT (match
), x
))
667 /* Just choose one. */
671 t
= OVL_CURRENT (match
);
676 if (t
&& t
!= error_mark_node
)
678 if (different_binding_level
)
680 if (decls_match (x
, t
))
681 /* The standard only says that the local extern
682 inherits linkage from the previous decl; in
683 particular, default args are not shared. Add
684 the decl into a hash table to make sure only
685 the previous decl in this case is seen by the
688 struct cxx_int_tree_map
*h
;
691 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
693 if (cp_function_chain
->extern_decl_map
== NULL
)
694 cp_function_chain
->extern_decl_map
695 = htab_create_ggc (20, cxx_int_tree_map_hash
,
696 cxx_int_tree_map_eq
, NULL
);
698 h
= ggc_alloc_cxx_int_tree_map ();
699 h
->uid
= DECL_UID (x
);
701 loc
= htab_find_slot_with_hash
702 (cp_function_chain
->extern_decl_map
, h
,
704 *(struct cxx_int_tree_map
**) loc
= h
;
707 else if (TREE_CODE (t
) == PARM_DECL
)
709 /* Check for duplicate params. */
710 tree d
= duplicate_decls (x
, t
, is_friend
);
714 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
715 || DECL_FUNCTION_TEMPLATE_P (x
))
716 && is_overloaded_fn (t
))
717 /* Don't do anything just yet. */;
718 else if (t
== wchar_decl_node
)
720 if (! DECL_IN_SYSTEM_HEADER (x
))
721 pedwarn (input_location
, OPT_pedantic
, "redeclaration of %<wchar_t%> as %qT",
724 /* Throw away the redeclaration. */
729 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
731 /* If the redeclaration failed, we can stop at this
733 if (olddecl
== error_mark_node
)
734 return error_mark_node
;
738 if (TREE_CODE (t
) == TYPE_DECL
)
739 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
743 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
745 /* A redeclaration of main, but not a duplicate of the
750 This function shall not be overloaded. */
751 error ("invalid redeclaration of %q+D", t
);
753 /* We don't try to push this declaration since that
760 /* If x has C linkage-specification, (extern "C"),
761 lookup its binding, in case it's already bound to an object.
762 The lookup is done in all namespaces.
763 If we find an existing binding, make sure it has the same
764 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
765 if ((TREE_CODE (x
) == FUNCTION_DECL
)
766 && DECL_EXTERN_C_P (x
)
767 /* We should ignore declarations happening in system headers. */
768 && !DECL_ARTIFICIAL (x
)
769 && !DECL_IN_SYSTEM_HEADER (x
))
771 tree previous
= lookup_extern_c_fun_in_all_ns (x
);
773 && !DECL_ARTIFICIAL (previous
)
774 && !DECL_IN_SYSTEM_HEADER (previous
)
775 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
777 /* In case either x or previous is declared to throw an exception,
778 make sure both exception specifications are equal. */
779 if (decls_match (x
, previous
))
781 tree x_exception_spec
= NULL_TREE
;
782 tree previous_exception_spec
= NULL_TREE
;
785 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
786 previous_exception_spec
=
787 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
788 if (!comp_except_specs (previous_exception_spec
,
792 pedwarn (input_location
, 0,
793 "declaration of %q#D with C language linkage",
795 pedwarn (input_location
, 0,
796 "conflicts with previous declaration %q+#D",
798 pedwarn (input_location
, 0,
799 "due to different exception specifications");
800 return error_mark_node
;
802 if (DECL_ASSEMBLER_NAME_SET_P (previous
))
803 SET_DECL_ASSEMBLER_NAME (x
,
804 DECL_ASSEMBLER_NAME (previous
));
808 pedwarn (input_location
, 0,
809 "declaration of %q#D with C language linkage", x
);
810 pedwarn (input_location
, 0,
811 "conflicts with previous declaration %q+#D",
817 check_template_shadow (x
);
819 /* If this is a function conjured up by the back end, massage it
820 so it looks friendly. */
821 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
823 retrofit_lang_decl (x
);
824 SET_DECL_LANGUAGE (x
, lang_c
);
828 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
830 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
831 if (!namespace_bindings_p ())
832 /* We do not need to create a binding for this name;
833 push_overloaded_decl will have already done so if
835 need_new_binding
= 0;
837 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
839 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
841 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
844 if (TREE_CODE (t
) == FUNCTION_DECL
|| DECL_FUNCTION_TEMPLATE_P (t
))
845 check_default_args (t
);
847 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
850 /* If declaring a type as a typedef, copy the type (unless we're
851 at line 0), and install this TYPE_DECL as the new type's typedef
852 name. See the extensive comment of set_underlying_type (). */
853 if (TREE_CODE (x
) == TYPE_DECL
)
855 tree type
= TREE_TYPE (x
);
857 if (DECL_IS_BUILTIN (x
)
858 || (TREE_TYPE (x
) != error_mark_node
859 && TYPE_NAME (type
) != x
860 /* We don't want to copy the type when all we're
861 doing is making a TYPE_DECL for the purposes of
863 && (!TYPE_NAME (type
)
864 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
865 set_underlying_type (x
);
867 if (type
!= error_mark_node
869 && TYPE_IDENTIFIER (type
))
870 set_identifier_type_value (DECL_NAME (x
), x
);
872 /* If this is a locally defined typedef in a function that
873 is not a template instantation, record it to implement
874 -Wunused-local-typedefs. */
875 if (current_instantiation () == NULL
876 || (current_instantiation ()->decl
!= current_function_decl
))
877 record_locally_defined_typedef (x
);
880 /* Multiple external decls of the same identifier ought to match.
882 We get warnings about inline functions where they are defined.
883 We get warnings about other functions from push_overloaded_decl.
885 Avoid duplicate warnings where they are used. */
886 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
890 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
891 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
892 decl
= OVL_FUNCTION (decl
);
894 if (decl
&& decl
!= error_mark_node
895 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
896 /* If different sort of thing, we already gave an error. */
897 && TREE_CODE (decl
) == TREE_CODE (x
)
898 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
900 permerror (input_location
, "type mismatch with previous external decl of %q#D", x
);
901 permerror (input_location
, "previous external decl of %q+#D", decl
);
905 if (TREE_CODE (x
) == FUNCTION_DECL
907 && !flag_friend_injection
)
909 /* This is a new declaration of a friend function, so hide
910 it from ordinary function lookup. */
911 DECL_ANTICIPATED (x
) = 1;
912 DECL_HIDDEN_FRIEND_P (x
) = 1;
915 /* This name is new in its binding level.
916 Install the new declaration and return it. */
917 if (namespace_bindings_p ())
919 /* Install a global value. */
921 /* If the first global decl has external linkage,
922 warn if we later see static one. */
923 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
924 TREE_PUBLIC (name
) = 1;
926 /* Bind the name for the entity. */
927 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
929 && (TREE_CODE (x
) == TYPE_DECL
930 || TREE_CODE (x
) == VAR_DECL
931 || TREE_CODE (x
) == NAMESPACE_DECL
932 || TREE_CODE (x
) == CONST_DECL
933 || TREE_CODE (x
) == TEMPLATE_DECL
))
934 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
936 /* If new decl is `static' and an `extern' was seen previously,
938 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
939 warn_extern_redeclared_static (x
, t
);
943 /* Here to install a non-global value. */
944 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
945 tree oldlocal
= NULL_TREE
;
946 cp_binding_level
*oldscope
= NULL
;
947 cxx_binding
*oldbinding
= outer_binding (name
, NULL
, true);
950 oldlocal
= oldbinding
->value
;
951 oldscope
= oldbinding
->scope
;
954 if (need_new_binding
)
956 push_local_binding (name
, x
, 0);
957 /* Because push_local_binding will hook X on to the
958 current_binding_level's name list, we don't want to
959 do that again below. */
960 need_new_binding
= 0;
963 /* If this is a TYPE_DECL, push it into the type value slot. */
964 if (TREE_CODE (x
) == TYPE_DECL
)
965 set_identifier_type_value (name
, x
);
967 /* Clear out any TYPE_DECL shadowed by a namespace so that
968 we won't think this is a type. The C struct hack doesn't
969 go through namespaces. */
970 if (TREE_CODE (x
) == NAMESPACE_DECL
)
971 set_identifier_type_value (name
, NULL_TREE
);
978 && TREE_CODE (oldlocal
) == VAR_DECL
979 && DECL_DEAD_FOR_LOCAL (oldlocal
))
980 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
982 if (oldlocal
== NULL_TREE
)
983 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
986 /* If this is an extern function declaration, see if we
987 have a global definition or declaration for the function. */
988 if (oldlocal
== NULL_TREE
990 && oldglobal
!= NULL_TREE
991 && TREE_CODE (x
) == FUNCTION_DECL
992 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
994 /* We have one. Their types must agree. */
995 if (decls_match (x
, oldglobal
))
999 warning (0, "extern declaration of %q#D doesn%'t match", x
);
1000 warning (0, "global declaration %q+#D", oldglobal
);
1003 /* If we have a local external declaration,
1004 and no file-scope declaration has yet been seen,
1005 then if we later have a file-scope decl it must not be static. */
1006 if (oldlocal
== NULL_TREE
1007 && oldglobal
== NULL_TREE
1008 && DECL_EXTERNAL (x
)
1010 TREE_PUBLIC (name
) = 1;
1012 /* Don't complain about the parms we push and then pop
1013 while tentatively parsing a function declarator. */
1014 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1017 /* Warn if shadowing an argument at the top level of the body. */
1018 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1019 /* Inline decls shadow nothing. */
1020 && !DECL_FROM_INLINE (x
)
1021 && (TREE_CODE (oldlocal
) == PARM_DECL
1022 || TREE_CODE (oldlocal
) == VAR_DECL
1023 /* If the old decl is a type decl, only warn if the
1024 old decl is an explicit typedef or if both the old
1025 and new decls are type decls. */
1026 || (TREE_CODE (oldlocal
) == TYPE_DECL
1027 && (!DECL_ARTIFICIAL (oldlocal
)
1028 || TREE_CODE (x
) == TYPE_DECL
)))
1029 /* Don't check for internally generated vars unless
1030 it's an implicit typedef (see create_implicit_typedef
1032 && (!DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
)))
1034 bool nowarn
= false;
1036 /* Don't complain if it's from an enclosing function. */
1037 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1038 && TREE_CODE (x
) != PARM_DECL
1039 && TREE_CODE (oldlocal
) == PARM_DECL
)
1041 /* Go to where the parms should be and see if we find
1043 cp_binding_level
*b
= current_binding_level
->level_chain
;
1045 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1046 /* Skip the ctor/dtor cleanup level. */
1050 if (b
->kind
== sk_function_parms
)
1052 error ("declaration of %q#D shadows a parameter", x
);
1057 /* The local structure or class can't use parameters of
1058 the containing function anyway. */
1059 if (DECL_CONTEXT (oldlocal
) != current_function_decl
)
1061 cp_binding_level
*scope
= current_binding_level
;
1062 tree context
= DECL_CONTEXT (oldlocal
);
1063 for (; scope
; scope
= scope
->level_chain
)
1065 if (scope
->kind
== sk_function_parms
1066 && scope
->this_entity
== context
)
1068 if (scope
->kind
== sk_class
1069 && !LAMBDA_TYPE_P (scope
->this_entity
))
1076 /* Error if redeclaring a local declared in a
1077 for-init-statement or in the condition of an if or
1078 switch statement when the new declaration is in the
1079 outermost block of the controlled statement.
1080 Redeclaring a variable from a for or while condition is
1081 detected elsewhere. */
1082 else if (TREE_CODE (oldlocal
) == VAR_DECL
1083 && oldscope
== current_binding_level
->level_chain
1084 && (oldscope
->kind
== sk_cond
1085 || oldscope
->kind
== sk_for
))
1087 error ("redeclaration of %q#D", x
);
1088 error ("%q+#D previously declared here", oldlocal
);
1091 if (warn_shadow
&& !nowarn
)
1093 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1094 warning_at (input_location
, OPT_Wshadow
,
1095 "declaration of %q#D shadows a parameter", x
);
1096 else if (is_capture_proxy (oldlocal
))
1097 warning_at (input_location
, OPT_Wshadow
,
1098 "declaration of %qD shadows a lambda capture",
1101 warning_at (input_location
, OPT_Wshadow
,
1102 "declaration of %qD shadows a previous local",
1104 warning_at (DECL_SOURCE_LOCATION (oldlocal
), OPT_Wshadow
,
1105 "shadowed declaration is here");
1109 /* Maybe warn if shadowing something else. */
1110 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1111 /* No shadow warnings for internally generated vars unless
1112 it's an implicit typedef (see create_implicit_typedef
1114 && (! DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
))
1115 /* No shadow warnings for vars made for inlining. */
1116 && ! DECL_FROM_INLINE (x
))
1120 if (current_class_ptr
)
1121 member
= lookup_member (current_class_type
,
1124 /*want_type=*/false);
1128 if (member
&& !TREE_STATIC (member
))
1130 /* Location of previous decl is not useful in this case. */
1131 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
1134 else if (oldglobal
!= NULL_TREE
1135 && (TREE_CODE (oldglobal
) == VAR_DECL
1136 /* If the old decl is a type decl, only warn if the
1137 old decl is an explicit typedef or if both the
1138 old and new decls are type decls. */
1139 || (TREE_CODE (oldglobal
) == TYPE_DECL
1140 && (!DECL_ARTIFICIAL (oldglobal
)
1141 || TREE_CODE (x
) == TYPE_DECL
))))
1142 /* XXX shadow warnings in outer-more namespaces */
1144 warning_at (input_location
, OPT_Wshadow
,
1145 "declaration of %qD shadows a global declaration", x
);
1146 warning_at (DECL_SOURCE_LOCATION (oldglobal
), OPT_Wshadow
,
1147 "shadowed declaration is here");
1152 if (TREE_CODE (x
) == VAR_DECL
)
1153 maybe_register_incomplete_var (x
);
1156 if (need_new_binding
)
1157 add_decl_to_level (x
,
1158 DECL_NAMESPACE_SCOPE_P (x
)
1159 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1160 : current_binding_level
);
1165 /* Wrapper for pushdecl_maybe_friend_1. */
1168 pushdecl_maybe_friend (tree x
, bool is_friend
)
1171 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1172 ret
= pushdecl_maybe_friend_1 (x
, is_friend
);
1173 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1177 /* Record a decl-node X as belonging to the current lexical scope. */
1182 return pushdecl_maybe_friend (x
, false);
1185 /* Enter DECL into the symbol table, if that's appropriate. Returns
1186 DECL, or a modified version thereof. */
1189 maybe_push_decl (tree decl
)
1191 tree type
= TREE_TYPE (decl
);
1193 /* Add this decl to the current binding level, but not if it comes
1194 from another scope, e.g. a static member variable. TEM may equal
1195 DECL or it may be a previous decl of the same name. */
1196 if (decl
== error_mark_node
1197 || (TREE_CODE (decl
) != PARM_DECL
1198 && DECL_CONTEXT (decl
) != NULL_TREE
1199 /* Definitions of namespace members outside their namespace are
1201 && !DECL_NAMESPACE_SCOPE_P (decl
))
1202 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1203 || type
== unknown_type_node
1204 /* The declaration of a template specialization does not affect
1205 the functions available for overload resolution, so we do not
1207 || (TREE_CODE (decl
) == FUNCTION_DECL
1208 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1211 return pushdecl (decl
);
1214 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1215 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1216 doesn't really belong to this binding level, that it got here
1217 through a using-declaration. */
1220 push_local_binding (tree id
, tree decl
, int flags
)
1222 cp_binding_level
*b
;
1224 /* Skip over any local classes. This makes sense if we call
1225 push_local_binding with a friend decl of a local class. */
1226 b
= innermost_nonclass_level ();
1228 if (lookup_name_innermost_nonclass_level (id
))
1230 /* Supplement the existing binding. */
1231 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1232 /* It didn't work. Something else must be bound at this
1233 level. Do not add DECL to the list of things to pop
1238 /* Create a new binding. */
1239 push_binding (id
, decl
, b
);
1241 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1242 /* We must put the OVERLOAD into a TREE_LIST since the
1243 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1244 decls that got here through a using-declaration. */
1245 decl
= build_tree_list (NULL_TREE
, decl
);
1247 /* And put DECL on the list of things declared by the current
1249 add_decl_to_level (decl
, b
);
1252 /* Check to see whether or not DECL is a variable that would have been
1253 in scope under the ARM, but is not in scope under the ANSI/ISO
1254 standard. If so, issue an error message. If name lookup would
1255 work in both cases, but return a different result, this function
1256 returns the result of ANSI/ISO lookup. Otherwise, it returns
1260 check_for_out_of_scope_variable (tree decl
)
1264 /* We only care about out of scope variables. */
1265 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1268 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1269 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1270 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1271 && DECL_DEAD_FOR_LOCAL (shadowed
))
1272 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1273 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1275 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1278 if (!DECL_ERROR_REPORTED (decl
))
1280 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1281 warning (0, " matches this %q+D under ISO standard rules",
1283 warning (0, " matches this %q+D under old rules", decl
);
1284 DECL_ERROR_REPORTED (decl
) = 1;
1289 /* If we have already complained about this declaration, there's no
1290 need to do it again. */
1291 if (DECL_ERROR_REPORTED (decl
))
1294 DECL_ERROR_REPORTED (decl
) = 1;
1296 if (TREE_TYPE (decl
) == error_mark_node
)
1299 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1301 error ("name lookup of %qD changed for ISO %<for%> scoping",
1303 error (" cannot use obsolete binding at %q+D because "
1304 "it has a destructor", decl
);
1305 return error_mark_node
;
1309 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1311 if (flag_permissive
)
1312 permerror (input_location
, " using obsolete binding at %q+D", decl
);
1318 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1327 /* true means unconditionally make a BLOCK for the next level pushed. */
1329 static bool keep_next_level_flag
;
1331 static int binding_depth
= 0;
1338 for (i
= 0; i
< depth
* 2; i
++)
1342 /* Return a string describing the kind of SCOPE we have. */
1344 cp_binding_level_descriptor (cp_binding_level
*scope
)
1346 /* The order of this table must match the "scope_kind"
1348 static const char* scope_kind_names
[] = {
1354 "function-parameter-scope",
1357 "template-parameter-scope",
1358 "template-explicit-spec-scope"
1360 const scope_kind kind
= scope
->explicit_spec_p
1361 ? sk_template_spec
: scope
->kind
;
1363 return scope_kind_names
[kind
];
1366 /* Output a debugging information about SCOPE when performing
1369 cp_binding_level_debug (cp_binding_level
*scope
, int line
, const char *action
)
1371 const char *desc
= cp_binding_level_descriptor (scope
);
1372 if (scope
->this_entity
)
1373 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1374 scope
->this_entity
, (void *) scope
, line
);
1376 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1379 /* Return the estimated initial size of the hashtable of a NAMESPACE
1382 static inline size_t
1383 namespace_scope_ht_size (tree ns
)
1385 tree name
= DECL_NAME (ns
);
1387 return name
== std_identifier
1388 ? NAMESPACE_STD_HT_SIZE
1389 : (name
== global_scope_name
1390 ? GLOBAL_SCOPE_HT_SIZE
1391 : NAMESPACE_ORDINARY_HT_SIZE
);
1394 /* A chain of binding_level structures awaiting reuse. */
1396 static GTY((deletable
)) cp_binding_level
*free_binding_level
;
1398 /* Insert SCOPE as the innermost binding level. */
1401 push_binding_level (cp_binding_level
*scope
)
1403 /* Add it to the front of currently active scopes stack. */
1404 scope
->level_chain
= current_binding_level
;
1405 current_binding_level
= scope
;
1406 keep_next_level_flag
= false;
1408 if (ENABLE_SCOPE_CHECKING
)
1410 scope
->binding_depth
= binding_depth
;
1411 indent (binding_depth
);
1412 cp_binding_level_debug (scope
, input_line
, "push");
1417 /* Create a new KIND scope and make it the top of the active scopes stack.
1418 ENTITY is the scope of the associated C++ entity (namespace, class,
1419 function, C++0x enumeration); it is NULL otherwise. */
1422 begin_scope (scope_kind kind
, tree entity
)
1424 cp_binding_level
*scope
;
1426 /* Reuse or create a struct for this binding level. */
1427 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1429 scope
= free_binding_level
;
1430 memset (scope
, 0, sizeof (cp_binding_level
));
1431 free_binding_level
= scope
->level_chain
;
1434 scope
= ggc_alloc_cleared_cp_binding_level ();
1436 scope
->this_entity
= entity
;
1437 scope
->more_cleanups_ok
= true;
1444 case sk_template_spec
:
1445 scope
->explicit_spec_p
= true;
1446 kind
= sk_template_parms
;
1448 case sk_template_parms
:
1455 case sk_scoped_enum
:
1456 case sk_function_parms
:
1458 scope
->keep
= keep_next_level_flag
;
1462 NAMESPACE_LEVEL (entity
) = scope
;
1463 scope
->static_decls
=
1464 VEC_alloc (tree
, gc
,
1465 DECL_NAME (entity
) == std_identifier
1466 || DECL_NAME (entity
) == global_scope_name
1471 /* Should not happen. */
1477 push_binding_level (scope
);
1482 /* We're about to leave current scope. Pop the top of the stack of
1483 currently active scopes. Return the enclosing scope, now active. */
1488 cp_binding_level
*scope
= current_binding_level
;
1490 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1491 current_binding_level
= class_binding_level
;
1493 /* We cannot leave a scope, if there are none left. */
1494 if (NAMESPACE_LEVEL (global_namespace
))
1495 gcc_assert (!global_scope_p (scope
));
1497 if (ENABLE_SCOPE_CHECKING
)
1499 indent (--binding_depth
);
1500 cp_binding_level_debug (scope
, input_line
, "leave");
1503 /* Move one nesting level up. */
1504 current_binding_level
= scope
->level_chain
;
1506 /* Namespace-scopes are left most probably temporarily, not
1507 completely; they can be reopened later, e.g. in namespace-extension
1508 or any name binding activity that requires us to resume a
1509 namespace. For classes, we cache some binding levels. For other
1510 scopes, we just make the structure available for reuse. */
1511 if (scope
->kind
!= sk_namespace
1512 && scope
->kind
!= sk_class
)
1514 scope
->level_chain
= free_binding_level
;
1515 gcc_assert (!ENABLE_SCOPE_CHECKING
1516 || scope
->binding_depth
== binding_depth
);
1517 free_binding_level
= scope
;
1520 /* Find the innermost enclosing class scope, and reset
1521 CLASS_BINDING_LEVEL appropriately. */
1522 if (scope
->kind
== sk_class
)
1524 class_binding_level
= NULL
;
1525 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1526 if (scope
->kind
== sk_class
)
1528 class_binding_level
= scope
;
1533 return current_binding_level
;
1537 resume_scope (cp_binding_level
* b
)
1539 /* Resuming binding levels is meant only for namespaces,
1540 and those cannot nest into classes. */
1541 gcc_assert (!class_binding_level
);
1542 /* Also, resuming a non-directly nested namespace is a no-no. */
1543 gcc_assert (b
->level_chain
== current_binding_level
);
1544 current_binding_level
= b
;
1545 if (ENABLE_SCOPE_CHECKING
)
1547 b
->binding_depth
= binding_depth
;
1548 indent (binding_depth
);
1549 cp_binding_level_debug (b
, input_line
, "resume");
1554 /* Return the innermost binding level that is not for a class scope. */
1556 static cp_binding_level
*
1557 innermost_nonclass_level (void)
1559 cp_binding_level
*b
;
1561 b
= current_binding_level
;
1562 while (b
->kind
== sk_class
)
1568 /* We're defining an object of type TYPE. If it needs a cleanup, but
1569 we're not allowed to add any more objects with cleanups to the current
1570 scope, create a new binding level. */
1573 maybe_push_cleanup_level (tree type
)
1575 if (type
!= error_mark_node
1576 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1577 && current_binding_level
->more_cleanups_ok
== 0)
1579 begin_scope (sk_cleanup
, NULL
);
1580 current_binding_level
->statement_list
= push_stmt_list ();
1584 /* Return true if we are in the global binding level. */
1587 global_bindings_p (void)
1589 return global_scope_p (current_binding_level
);
1592 /* True if we are currently in a toplevel binding level. This
1593 means either the global binding level or a namespace in a toplevel
1594 binding level. Since there are no non-toplevel namespace levels,
1595 this really means any namespace or template parameter level. We
1596 also include a class whose context is toplevel. */
1599 toplevel_bindings_p (void)
1601 cp_binding_level
*b
= innermost_nonclass_level ();
1603 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1606 /* True if this is a namespace scope, or if we are defining a class
1607 which is itself at namespace scope, or whose enclosing class is
1608 such a class, etc. */
1611 namespace_bindings_p (void)
1613 cp_binding_level
*b
= innermost_nonclass_level ();
1615 return b
->kind
== sk_namespace
;
1618 /* True if the innermost non-class scope is a block scope. */
1621 local_bindings_p (void)
1623 cp_binding_level
*b
= innermost_nonclass_level ();
1624 return b
->kind
< sk_function_parms
|| b
->kind
== sk_omp
;
1627 /* True if the current level needs to have a BLOCK made. */
1632 return (current_binding_level
->blocks
!= NULL_TREE
1633 || current_binding_level
->keep
1634 || current_binding_level
->kind
== sk_cleanup
1635 || current_binding_level
->names
!= NULL_TREE
1636 || current_binding_level
->using_directives
);
1639 /* Returns the kind of the innermost scope. */
1642 innermost_scope_kind (void)
1644 return current_binding_level
->kind
;
1647 /* Returns true if this scope was created to store template parameters. */
1650 template_parm_scope_p (void)
1652 return innermost_scope_kind () == sk_template_parms
;
1655 /* If KEEP is true, make a BLOCK node for the next binding level,
1656 unconditionally. Otherwise, use the normal logic to decide whether
1657 or not to create a BLOCK. */
1660 keep_next_level (bool keep
)
1662 keep_next_level_flag
= keep
;
1665 /* Return the list of declarations of the current level.
1666 Note that this list is in reverse order unless/until
1667 you nreverse it; and when you do nreverse it, you must
1668 store the result back using `storedecls' or you will lose. */
1673 return current_binding_level
->names
;
1676 /* Return how many function prototypes we are currently nested inside. */
1679 function_parm_depth (void)
1682 cp_binding_level
*b
;
1684 for (b
= current_binding_level
;
1685 b
->kind
== sk_function_parms
;
1692 /* For debugging. */
1693 static int no_print_functions
= 0;
1694 static int no_print_builtins
= 0;
1697 print_binding_level (cp_binding_level
* lvl
)
1701 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1702 if (lvl
->more_cleanups_ok
)
1703 fprintf (stderr
, " more-cleanups-ok");
1704 if (lvl
->have_cleanups
)
1705 fprintf (stderr
, " have-cleanups");
1706 fprintf (stderr
, "\n");
1709 fprintf (stderr
, " names:\t");
1710 /* We can probably fit 3 names to a line? */
1711 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1713 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1715 if (no_print_builtins
1716 && (TREE_CODE (t
) == TYPE_DECL
)
1717 && DECL_IS_BUILTIN (t
))
1720 /* Function decls tend to have longer names. */
1721 if (TREE_CODE (t
) == FUNCTION_DECL
)
1728 fprintf (stderr
, "\n\t");
1731 print_node_brief (stderr
, "", t
, 0);
1732 if (t
== error_mark_node
)
1736 fprintf (stderr
, "\n");
1738 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1741 cp_class_binding
*b
;
1742 fprintf (stderr
, " class-shadowed:");
1743 FOR_EACH_VEC_ELT (cp_class_binding
, lvl
->class_shadowed
, i
, b
)
1744 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1745 fprintf (stderr
, "\n");
1747 if (lvl
->type_shadowed
)
1749 fprintf (stderr
, " type-shadowed:");
1750 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1752 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1754 fprintf (stderr
, "\n");
1759 print_other_binding_stack (cp_binding_level
*stack
)
1761 cp_binding_level
*level
;
1762 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1764 fprintf (stderr
, "binding level %p\n", (void *) level
);
1765 print_binding_level (level
);
1770 print_binding_stack (void)
1772 cp_binding_level
*b
;
1773 fprintf (stderr
, "current_binding_level=%p\n"
1774 "class_binding_level=%p\n"
1775 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1776 (void *) current_binding_level
, (void *) class_binding_level
,
1777 (void *) NAMESPACE_LEVEL (global_namespace
));
1778 if (class_binding_level
)
1780 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1781 if (b
== current_binding_level
)
1784 b
= class_binding_level
;
1786 b
= current_binding_level
;
1789 b
= current_binding_level
;
1790 print_other_binding_stack (b
);
1791 fprintf (stderr
, "global:\n");
1792 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1795 /* Return the type associated with ID. */
1798 identifier_type_value_1 (tree id
)
1800 /* There is no type with that name, anywhere. */
1801 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1803 /* This is not the type marker, but the real thing. */
1804 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1805 return REAL_IDENTIFIER_TYPE_VALUE (id
);
1806 /* Have to search for it. It must be on the global level, now.
1807 Ask lookup_name not to return non-types. */
1808 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1810 return TREE_TYPE (id
);
1814 /* Wrapper for identifier_type_value_1. */
1817 identifier_type_value (tree id
)
1820 timevar_start (TV_NAME_LOOKUP
);
1821 ret
= identifier_type_value_1 (id
);
1822 timevar_stop (TV_NAME_LOOKUP
);
1827 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1828 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1831 identifier_global_value (tree t
)
1833 return IDENTIFIER_GLOBAL_VALUE (t
);
1836 /* Push a definition of struct, union or enum tag named ID. into
1837 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1838 the tag ID is not already defined. */
1841 set_identifier_type_value_with_scope (tree id
, tree decl
, cp_binding_level
*b
)
1845 if (b
->kind
!= sk_namespace
)
1847 /* Shadow the marker, not the real thing, so that the marker
1848 gets restored later. */
1849 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1851 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1852 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1853 TREE_TYPE (b
->type_shadowed
) = type
;
1857 cxx_binding
*binding
=
1858 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1861 supplement_binding (binding
, decl
);
1863 binding
->value
= decl
;
1865 /* Store marker instead of real type. */
1866 type
= global_type_node
;
1868 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1871 /* As set_identifier_type_value_with_scope, but using
1872 current_binding_level. */
1875 set_identifier_type_value (tree id
, tree decl
)
1877 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1880 /* Return the name for the constructor (or destructor) for the
1881 specified class TYPE. When given a template, this routine doesn't
1882 lose the specialization. */
1885 constructor_name_full (tree type
)
1887 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1890 /* Return the name for the constructor (or destructor) for the
1891 specified class. When given a template, return the plain
1892 unspecialized name. */
1895 constructor_name (tree type
)
1898 name
= constructor_name_full (type
);
1899 if (IDENTIFIER_TEMPLATE (name
))
1900 name
= IDENTIFIER_TEMPLATE (name
);
1904 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1905 which must be a class type. */
1908 constructor_name_p (tree name
, tree type
)
1912 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
1917 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1920 ctor_name
= constructor_name_full (type
);
1921 if (name
== ctor_name
)
1923 if (IDENTIFIER_TEMPLATE (ctor_name
)
1924 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1929 /* Counter used to create anonymous type names. */
1931 static GTY(()) int anon_cnt
;
1933 /* Return an IDENTIFIER which can be used as a name for
1934 anonymous structs and unions. */
1937 make_anon_name (void)
1941 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1942 return get_identifier (buf
);
1945 /* This code is practically identical to that for creating
1946 anonymous names, but is just used for lambdas instead. This is necessary
1947 because anonymous names are recognized and cannot be passed to template
1949 /* FIXME is this still necessary? */
1951 static GTY(()) int lambda_cnt
= 0;
1954 make_lambda_name (void)
1958 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
1959 return get_identifier (buf
);
1962 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1964 static inline cxx_binding
*
1965 find_binding (cp_binding_level
*scope
, cxx_binding
*binding
)
1967 for (; binding
!= NULL
; binding
= binding
->previous
)
1968 if (binding
->scope
== scope
)
1971 return (cxx_binding
*)0;
1974 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1976 static inline cxx_binding
*
1977 cp_binding_level_find_binding_for_name (cp_binding_level
*scope
, tree name
)
1979 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1982 /* Fold-in case where NAME is used only once. */
1983 if (scope
== b
->scope
&& b
->previous
== NULL
)
1985 return find_binding (scope
, b
);
1990 /* Always returns a binding for name in scope. If no binding is
1991 found, make a new one. */
1993 static cxx_binding
*
1994 binding_for_name (cp_binding_level
*scope
, tree name
)
1996 cxx_binding
*result
;
1998 result
= cp_binding_level_find_binding_for_name (scope
, name
);
2001 /* Not found, make a new one. */
2002 result
= cxx_binding_make (NULL
, NULL
);
2003 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2004 result
->scope
= scope
;
2005 result
->is_local
= false;
2006 result
->value_is_inherited
= false;
2007 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2011 /* Walk through the bindings associated to the name of FUNCTION,
2012 and return the first declaration of a function with a
2013 "C" linkage specification, a.k.a 'extern "C"'.
2014 This function looks for the binding, regardless of which scope it
2015 has been defined in. It basically looks in all the known scopes.
2016 Note that this function does not lookup for bindings of builtin functions
2017 or for functions declared in system headers. */
2019 lookup_extern_c_fun_in_all_ns (tree function
)
2024 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
2026 name
= DECL_NAME (function
);
2027 gcc_assert (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
);
2029 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2031 iter
= iter
->previous
)
2034 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2036 tree decl
= OVL_CURRENT (ovl
);
2038 && TREE_CODE (decl
) == FUNCTION_DECL
2039 && DECL_EXTERN_C_P (decl
)
2040 && !DECL_ARTIFICIAL (decl
))
2049 /* Returns a list of C-linkage decls with the name NAME. */
2052 c_linkage_bindings (tree name
)
2054 tree decls
= NULL_TREE
;
2057 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2059 iter
= iter
->previous
)
2062 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2064 tree decl
= OVL_CURRENT (ovl
);
2066 && DECL_EXTERN_C_P (decl
)
2067 && !DECL_ARTIFICIAL (decl
))
2069 if (decls
== NULL_TREE
)
2072 decls
= tree_cons (NULL_TREE
, decl
, decls
);
2079 /* Insert another USING_DECL into the current binding level, returning
2080 this declaration. If this is a redeclaration, do nothing, and
2081 return NULL_TREE if this not in namespace scope (in namespace
2082 scope, a using decl might extend any previous bindings). */
2085 push_using_decl_1 (tree scope
, tree name
)
2089 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
2090 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
2091 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
2092 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
2095 return namespace_bindings_p () ? decl
: NULL_TREE
;
2096 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2097 USING_DECL_SCOPE (decl
) = scope
;
2098 DECL_CHAIN (decl
) = current_binding_level
->usings
;
2099 current_binding_level
->usings
= decl
;
2103 /* Wrapper for push_using_decl_1. */
2106 push_using_decl (tree scope
, tree name
)
2109 timevar_start (TV_NAME_LOOKUP
);
2110 ret
= push_using_decl_1 (scope
, name
);
2111 timevar_stop (TV_NAME_LOOKUP
);
2115 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2116 caller to set DECL_CONTEXT properly.
2118 Note that this must only be used when X will be the new innermost
2119 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2120 without checking to see if the current IDENTIFIER_BINDING comes from a
2121 closer binding level than LEVEL. */
2124 pushdecl_with_scope_1 (tree x
, cp_binding_level
*level
, bool is_friend
)
2126 cp_binding_level
*b
;
2127 tree function_decl
= current_function_decl
;
2129 current_function_decl
= NULL_TREE
;
2130 if (level
->kind
== sk_class
)
2132 b
= class_binding_level
;
2133 class_binding_level
= level
;
2134 pushdecl_class_level (x
);
2135 class_binding_level
= b
;
2139 b
= current_binding_level
;
2140 current_binding_level
= level
;
2141 x
= pushdecl_maybe_friend (x
, is_friend
);
2142 current_binding_level
= b
;
2144 current_function_decl
= function_decl
;
2148 /* Wrapper for pushdecl_with_scope_1. */
2151 pushdecl_with_scope (tree x
, cp_binding_level
*level
, bool is_friend
)
2154 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2155 ret
= pushdecl_with_scope_1 (x
, level
, is_friend
);
2156 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2161 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2162 other definitions already in place. We get around this by making
2163 the value of the identifier point to a list of all the things that
2164 want to be referenced by that name. It is then up to the users of
2165 that name to decide what to do with that list.
2167 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2168 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2170 FLAGS is a bitwise-or of the following values:
2171 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2173 PUSH_USING: DECL is being pushed as the result of a using
2176 IS_FRIEND is true if this is a friend declaration.
2178 The value returned may be a previous declaration if we guessed wrong
2179 about what language DECL should belong to (C or C++). Otherwise,
2180 it's always DECL (and never something that's not a _DECL). */
2183 push_overloaded_decl_1 (tree decl
, int flags
, bool is_friend
)
2185 tree name
= DECL_NAME (decl
);
2188 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2191 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2193 old
= lookup_name_innermost_nonclass_level (name
);
2197 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2199 tree t
= TREE_TYPE (old
);
2200 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2201 && (! DECL_IN_SYSTEM_HEADER (decl
)
2202 || ! DECL_IN_SYSTEM_HEADER (old
)))
2203 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2206 else if (is_overloaded_fn (old
))
2210 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2212 tree fn
= OVL_CURRENT (tmp
);
2215 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2216 && !(flags
& PUSH_USING
)
2217 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2218 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
2219 && ! decls_match (fn
, decl
))
2220 error ("%q#D conflicts with previous using declaration %q#D",
2223 dup
= duplicate_decls (decl
, fn
, is_friend
);
2224 /* If DECL was a redeclaration of FN -- even an invalid
2225 one -- pass that information along to our caller. */
2226 if (dup
== fn
|| dup
== error_mark_node
)
2230 /* We don't overload implicit built-ins. duplicate_decls()
2231 may fail to merge the decls if the new decl is e.g. a
2232 template function. */
2233 if (TREE_CODE (old
) == FUNCTION_DECL
2234 && DECL_ANTICIPATED (old
)
2235 && !DECL_HIDDEN_FRIEND_P (old
))
2238 else if (old
== error_mark_node
)
2239 /* Ignore the undefined symbol marker. */
2243 error ("previous non-function declaration %q+#D", old
);
2244 error ("conflicts with function declaration %q#D", decl
);
2249 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2250 /* If it's a using declaration, we always need to build an OVERLOAD,
2251 because it's the only way to remember that the declaration comes
2252 from 'using', and have the lookup behave correctly. */
2253 || (flags
& PUSH_USING
))
2255 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2256 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2258 new_binding
= ovl_cons (decl
, old
);
2259 if (flags
& PUSH_USING
)
2260 OVL_USED (new_binding
) = 1;
2263 /* NAME is not ambiguous. */
2267 set_namespace_binding (name
, current_namespace
, new_binding
);
2270 /* We only create an OVERLOAD if there was a previous binding at
2271 this level, or if decl is a template. In the former case, we
2272 need to remove the old binding and replace it with the new
2273 binding. We must also run through the NAMES on the binding
2274 level where the name was bound to update the chain. */
2276 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2280 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2282 d
= &TREE_CHAIN (*d
))
2284 || (TREE_CODE (*d
) == TREE_LIST
2285 && TREE_VALUE (*d
) == old
))
2287 if (TREE_CODE (*d
) == TREE_LIST
)
2288 /* Just replace the old binding with the new. */
2289 TREE_VALUE (*d
) = new_binding
;
2291 /* Build a TREE_LIST to wrap the OVERLOAD. */
2292 *d
= tree_cons (NULL_TREE
, new_binding
,
2295 /* And update the cxx_binding node. */
2296 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2300 /* We should always find a previous binding in this case. */
2304 /* Install the new binding. */
2305 push_local_binding (name
, new_binding
, flags
);
2311 /* Wrapper for push_overloaded_decl_1. */
2314 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2317 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2318 ret
= push_overloaded_decl_1 (decl
, flags
, is_friend
);
2319 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2323 /* Check a non-member using-declaration. Return the name and scope
2324 being used, and the USING_DECL, or NULL_TREE on failure. */
2327 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2329 /* [namespace.udecl]
2330 A using-declaration for a class member shall be a
2331 member-declaration. */
2334 error ("%qT is not a namespace", scope
);
2337 else if (scope
== error_mark_node
)
2340 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2343 A using-declaration shall not name a template-id. */
2344 error ("a using-declaration cannot specify a template-id. "
2345 "Try %<using %D%>", name
);
2349 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2351 error ("namespace %qD not allowed in using-declaration", decl
);
2355 if (TREE_CODE (decl
) == SCOPE_REF
)
2357 /* It's a nested name with template parameter dependent scope.
2358 This can only be using-declaration for class member. */
2359 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2363 if (is_overloaded_fn (decl
))
2364 decl
= get_first_fn (decl
);
2366 gcc_assert (DECL_P (decl
));
2368 /* Make a USING_DECL. */
2369 return push_using_decl (scope
, name
);
2372 /* Process local and global using-declarations. */
2375 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2376 tree
*newval
, tree
*newtype
)
2378 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2380 *newval
= *newtype
= NULL_TREE
;
2381 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2385 if (!decls
.value
&& !decls
.type
)
2387 error ("%qD not declared", name
);
2391 /* Shift the old and new bindings around so we're comparing class and
2392 enumeration names to each other. */
2393 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2399 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2401 decls
.type
= decls
.value
;
2402 decls
.value
= NULL_TREE
;
2405 /* It is impossible to overload a built-in function; any explicit
2406 declaration eliminates the built-in declaration. So, if OLDVAL
2407 is a built-in, then we can just pretend it isn't there. */
2409 && TREE_CODE (oldval
) == FUNCTION_DECL
2410 && DECL_ANTICIPATED (oldval
)
2411 && !DECL_HIDDEN_FRIEND_P (oldval
))
2416 /* Check for using functions. */
2417 if (is_overloaded_fn (decls
.value
))
2421 if (oldval
&& !is_overloaded_fn (oldval
))
2423 error ("%qD is already declared in this scope", name
);
2428 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2430 tree new_fn
= OVL_CURRENT (tmp
);
2432 /* [namespace.udecl]
2434 If a function declaration in namespace scope or block
2435 scope has the same name and the same parameter types as a
2436 function introduced by a using declaration the program is
2438 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2440 tree old_fn
= OVL_CURRENT (tmp1
);
2442 if (new_fn
== old_fn
)
2443 /* The function already exists in the current namespace. */
2445 else if (OVL_USED (tmp1
))
2446 continue; /* this is a using decl */
2447 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2448 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2450 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2451 || DECL_HIDDEN_FRIEND_P (old_fn
));
2453 /* There was already a non-using declaration in
2454 this scope with the same parameter types. If both
2455 are the same extern "C" functions, that's ok. */
2456 if (decls_match (new_fn
, old_fn
))
2460 error ("%qD is already declared in this scope", name
);
2466 /* If we broke out of the loop, there's no reason to add
2467 this function to the using declarations for this
2472 /* If we are adding to an existing OVERLOAD, then we no
2473 longer know the type of the set of functions. */
2474 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2475 TREE_TYPE (*newval
) = unknown_type_node
;
2476 /* Add this new function to the set. */
2477 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2478 /* If there is only one function, then we use its type. (A
2479 using-declaration naming a single function can be used in
2480 contexts where overload resolution cannot be
2482 if (TREE_CODE (*newval
) != OVERLOAD
)
2484 *newval
= ovl_cons (*newval
, NULL_TREE
);
2485 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2487 OVL_USED (*newval
) = 1;
2492 *newval
= decls
.value
;
2493 if (oldval
&& !decls_match (*newval
, oldval
))
2494 error ("%qD is already declared in this scope", name
);
2500 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2502 error ("reference to %qD is ambiguous", name
);
2503 print_candidates (decls
.type
);
2507 *newtype
= decls
.type
;
2508 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2509 error ("%qD is already declared in this scope", name
);
2512 /* If *newval is empty, shift any class or enumeration name down. */
2516 *newtype
= NULL_TREE
;
2520 /* Process a using-declaration at function scope. */
2523 do_local_using_decl (tree decl
, tree scope
, tree name
)
2525 tree oldval
, oldtype
, newval
, newtype
;
2526 tree orig_decl
= decl
;
2528 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2529 if (decl
== NULL_TREE
)
2532 if (building_stmt_list_p ()
2533 && at_function_scope_p ())
2534 add_decl_expr (decl
);
2536 oldval
= lookup_name_innermost_nonclass_level (name
);
2537 oldtype
= lookup_type_current_level (name
);
2539 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2543 if (is_overloaded_fn (newval
))
2547 /* We only need to push declarations for those functions
2548 that were not already bound in the current level.
2549 The old value might be NULL_TREE, it might be a single
2550 function, or an OVERLOAD. */
2551 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2552 term
= OVL_FUNCTION (oldval
);
2555 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2557 push_overloaded_decl (OVL_CURRENT (fn
),
2558 PUSH_LOCAL
| PUSH_USING
,
2562 push_local_binding (name
, newval
, PUSH_USING
);
2566 push_local_binding (name
, newtype
, PUSH_USING
);
2567 set_identifier_type_value (name
, newtype
);
2570 /* Emit debug info. */
2571 if (!processing_template_decl
)
2572 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2575 /* Returns true if ROOT (a namespace, class, or function) encloses
2576 CHILD. CHILD may be either a class type or a namespace. */
2579 is_ancestor (tree root
, tree child
)
2581 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2582 || TREE_CODE (root
) == FUNCTION_DECL
2583 || CLASS_TYPE_P (root
)));
2584 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2585 || CLASS_TYPE_P (child
)));
2587 /* The global namespace encloses everything. */
2588 if (root
== global_namespace
)
2593 /* If we've run out of scopes, stop. */
2596 /* If we've reached the ROOT, it encloses CHILD. */
2599 /* Go out one level. */
2601 child
= TYPE_NAME (child
);
2602 child
= DECL_CONTEXT (child
);
2606 /* Enter the class or namespace scope indicated by T suitable for name
2607 lookup. T can be arbitrary scope, not necessary nested inside the
2608 current scope. Returns a non-null scope to pop iff pop_scope
2609 should be called later to exit this scope. */
2614 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2615 push_decl_namespace (t
);
2616 else if (CLASS_TYPE_P (t
))
2618 if (!at_class_scope_p ()
2619 || !same_type_p (current_class_type
, t
))
2620 push_nested_class (t
);
2622 /* T is the same as the current scope. There is therefore no
2623 need to re-enter the scope. Since we are not actually
2624 pushing a new scope, our caller should not call
2632 /* Leave scope pushed by push_scope. */
2639 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2640 pop_decl_namespace ();
2641 else if CLASS_TYPE_P (t
)
2642 pop_nested_class ();
2645 /* Subroutine of push_inner_scope. */
2648 push_inner_scope_r (tree outer
, tree inner
)
2653 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2656 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2658 push_inner_scope_r (outer
, prev
);
2659 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2661 cp_binding_level
*save_template_parm
= 0;
2662 /* Temporary take out template parameter scopes. They are saved
2663 in reversed order in save_template_parm. */
2664 while (current_binding_level
->kind
== sk_template_parms
)
2666 cp_binding_level
*b
= current_binding_level
;
2667 current_binding_level
= b
->level_chain
;
2668 b
->level_chain
= save_template_parm
;
2669 save_template_parm
= b
;
2672 resume_scope (NAMESPACE_LEVEL (inner
));
2673 current_namespace
= inner
;
2675 /* Restore template parameter scopes. */
2676 while (save_template_parm
)
2678 cp_binding_level
*b
= save_template_parm
;
2679 save_template_parm
= b
->level_chain
;
2680 b
->level_chain
= current_binding_level
;
2681 current_binding_level
= b
;
2688 /* Enter the scope INNER from current scope. INNER must be a scope
2689 nested inside current scope. This works with both name lookup and
2690 pushing name into scope. In case a template parameter scope is present,
2691 namespace is pushed under the template parameter scope according to
2692 name lookup rule in 14.6.1/6.
2694 Return the former current scope suitable for pop_inner_scope. */
2697 push_inner_scope (tree inner
)
2699 tree outer
= current_scope ();
2701 outer
= current_namespace
;
2703 push_inner_scope_r (outer
, inner
);
2707 /* Exit the current scope INNER back to scope OUTER. */
2710 pop_inner_scope (tree outer
, tree inner
)
2713 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2716 while (outer
!= inner
)
2718 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2720 cp_binding_level
*save_template_parm
= 0;
2721 /* Temporary take out template parameter scopes. They are saved
2722 in reversed order in save_template_parm. */
2723 while (current_binding_level
->kind
== sk_template_parms
)
2725 cp_binding_level
*b
= current_binding_level
;
2726 current_binding_level
= b
->level_chain
;
2727 b
->level_chain
= save_template_parm
;
2728 save_template_parm
= b
;
2733 /* Restore template parameter scopes. */
2734 while (save_template_parm
)
2736 cp_binding_level
*b
= save_template_parm
;
2737 save_template_parm
= b
->level_chain
;
2738 b
->level_chain
= current_binding_level
;
2739 current_binding_level
= b
;
2745 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2749 /* Do a pushlevel for class declarations. */
2752 pushlevel_class (void)
2754 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2757 /* ...and a poplevel for class declarations. */
2760 poplevel_class (void)
2762 cp_binding_level
*level
= class_binding_level
;
2763 cp_class_binding
*cb
;
2767 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2768 gcc_assert (level
!= 0);
2770 /* If we're leaving a toplevel class, cache its binding level. */
2771 if (current_class_depth
== 1)
2772 previous_class_level
= level
;
2773 for (shadowed
= level
->type_shadowed
;
2775 shadowed
= TREE_CHAIN (shadowed
))
2776 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2778 /* Remove the bindings for all of the class-level declarations. */
2779 if (level
->class_shadowed
)
2781 FOR_EACH_VEC_ELT (cp_class_binding
, level
->class_shadowed
, i
, cb
)
2783 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
->previous
;
2784 cxx_binding_free (cb
->base
);
2786 ggc_free (level
->class_shadowed
);
2787 level
->class_shadowed
= NULL
;
2790 /* Now, pop out of the binding level which we created up in the
2791 `pushlevel_class' routine. */
2792 gcc_assert (current_binding_level
== level
);
2794 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2797 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2798 appropriate. DECL is the value to which a name has just been
2799 bound. CLASS_TYPE is the class in which the lookup occurred. */
2802 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2805 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2809 if (TREE_CODE (decl
) == OVERLOAD
)
2810 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2813 gcc_assert (DECL_P (decl
));
2814 context
= context_for_name_lookup (decl
);
2817 if (is_properly_derived_from (class_type
, context
))
2818 INHERITED_VALUE_BINDING_P (binding
) = 1;
2820 INHERITED_VALUE_BINDING_P (binding
) = 0;
2822 else if (binding
->value
== decl
)
2823 /* We only encounter a TREE_LIST when there is an ambiguity in the
2824 base classes. Such an ambiguity can be overridden by a
2825 definition in this class. */
2826 INHERITED_VALUE_BINDING_P (binding
) = 1;
2828 INHERITED_VALUE_BINDING_P (binding
) = 0;
2831 /* Make the declaration of X appear in CLASS scope. */
2834 pushdecl_class_level (tree x
)
2837 bool is_valid
= true;
2840 /* Do nothing if we're adding to an outer lambda closure type,
2841 outer_binding will add it later if it's needed. */
2842 if (current_class_type
!= class_binding_level
->this_entity
)
2845 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2846 /* Get the name of X. */
2847 if (TREE_CODE (x
) == OVERLOAD
)
2848 name
= DECL_NAME (get_first_fn (x
));
2850 name
= DECL_NAME (x
);
2854 is_valid
= push_class_level_binding (name
, x
);
2855 if (TREE_CODE (x
) == TYPE_DECL
)
2856 set_identifier_type_value (name
, x
);
2858 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2860 /* If X is an anonymous aggregate, all of its members are
2861 treated as if they were members of the class containing the
2862 aggregate, for naming purposes. */
2865 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= DECL_CHAIN (f
))
2867 location_t save_location
= input_location
;
2868 input_location
= DECL_SOURCE_LOCATION (f
);
2869 if (!pushdecl_class_level (f
))
2871 input_location
= save_location
;
2874 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2878 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2879 scope. If the value returned is non-NULL, and the PREVIOUS field
2880 is not set, callers must set the PREVIOUS field explicitly. */
2882 static cxx_binding
*
2883 get_class_binding (tree name
, cp_binding_level
*scope
)
2888 cxx_binding
*binding
;
2890 class_type
= scope
->this_entity
;
2892 /* Get the type binding. */
2893 type_binding
= lookup_member (class_type
, name
,
2894 /*protect=*/2, /*want_type=*/true);
2895 /* Get the value binding. */
2896 value_binding
= lookup_member (class_type
, name
,
2897 /*protect=*/2, /*want_type=*/false);
2900 && (TREE_CODE (value_binding
) == TYPE_DECL
2901 || DECL_CLASS_TEMPLATE_P (value_binding
)
2902 || (TREE_CODE (value_binding
) == TREE_LIST
2903 && TREE_TYPE (value_binding
) == error_mark_node
2904 && (TREE_CODE (TREE_VALUE (value_binding
))
2906 /* We found a type binding, even when looking for a non-type
2907 binding. This means that we already processed this binding
2910 else if (value_binding
)
2912 if (TREE_CODE (value_binding
) == TREE_LIST
2913 && TREE_TYPE (value_binding
) == error_mark_node
)
2914 /* NAME is ambiguous. */
2916 else if (BASELINK_P (value_binding
))
2917 /* NAME is some overloaded functions. */
2918 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2921 /* If we found either a type binding or a value binding, create a
2922 new binding object. */
2923 if (type_binding
|| value_binding
)
2925 binding
= new_class_binding (name
,
2929 /* This is a class-scope binding, not a block-scope binding. */
2930 LOCAL_BINDING_P (binding
) = 0;
2931 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2939 /* Make the declaration(s) of X appear in CLASS scope under the name
2940 NAME. Returns true if the binding is valid. */
2943 push_class_level_binding_1 (tree name
, tree x
)
2945 cxx_binding
*binding
;
2949 /* The class_binding_level will be NULL if x is a template
2950 parameter name in a member template. */
2951 if (!class_binding_level
)
2954 if (name
== error_mark_node
)
2957 /* Check for invalid member names. */
2958 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2959 /* Check that we're pushing into the right binding level. */
2960 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
2962 /* We could have been passed a tree list if this is an ambiguous
2963 declaration. If so, pull the declaration out because
2964 check_template_shadow will not handle a TREE_LIST. */
2965 if (TREE_CODE (decl
) == TREE_LIST
2966 && TREE_TYPE (decl
) == error_mark_node
)
2967 decl
= TREE_VALUE (decl
);
2969 if (!check_template_shadow (decl
))
2974 If T is the name of a class, then each of the following shall
2975 have a name different from T:
2977 -- every static data member of class T;
2979 -- every member of class T that is itself a type;
2981 -- every enumerator of every member of class T that is an
2984 -- every member of every anonymous union that is a member of
2987 (Non-static data members were also forbidden to have the same
2988 name as T until TC1.) */
2989 if ((TREE_CODE (x
) == VAR_DECL
2990 || TREE_CODE (x
) == CONST_DECL
2991 || (TREE_CODE (x
) == TYPE_DECL
2992 && !DECL_SELF_REFERENCE_P (x
))
2993 /* A data member of an anonymous union. */
2994 || (TREE_CODE (x
) == FIELD_DECL
2995 && DECL_CONTEXT (x
) != current_class_type
))
2996 && DECL_NAME (x
) == constructor_name (current_class_type
))
2998 tree scope
= context_for_name_lookup (x
);
2999 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
3001 error ("%qD has the same name as the class in which it is "
3008 /* Get the current binding for NAME in this class, if any. */
3009 binding
= IDENTIFIER_BINDING (name
);
3010 if (!binding
|| binding
->scope
!= class_binding_level
)
3012 binding
= get_class_binding (name
, class_binding_level
);
3013 /* If a new binding was created, put it at the front of the
3014 IDENTIFIER_BINDING list. */
3017 binding
->previous
= IDENTIFIER_BINDING (name
);
3018 IDENTIFIER_BINDING (name
) = binding
;
3022 /* If there is already a binding, then we may need to update the
3024 if (binding
&& binding
->value
)
3026 tree bval
= binding
->value
;
3027 tree old_decl
= NULL_TREE
;
3029 if (INHERITED_VALUE_BINDING_P (binding
))
3031 /* If the old binding was from a base class, and was for a
3032 tag name, slide it over to make room for the new binding.
3033 The old binding is still visible if explicitly qualified
3034 with a class-key. */
3035 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
3036 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
3038 old_decl
= binding
->type
;
3039 binding
->type
= bval
;
3040 binding
->value
= NULL_TREE
;
3041 INHERITED_VALUE_BINDING_P (binding
) = 0;
3046 /* Any inherited type declaration is hidden by the type
3047 declaration in the derived class. */
3048 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
))
3049 binding
->type
= NULL_TREE
;
3052 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
3054 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
3056 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
3058 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
3061 if (old_decl
&& binding
->scope
== class_binding_level
)
3064 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3065 here. This function is only used to register bindings
3066 from with the class definition itself. */
3067 INHERITED_VALUE_BINDING_P (binding
) = 0;
3072 /* Note that we declared this value so that we can issue an error if
3073 this is an invalid redeclaration of a name already used for some
3075 note_name_declared_in_class (name
, decl
);
3077 /* If we didn't replace an existing binding, put the binding on the
3078 stack of bindings for the identifier, and update the shadowed
3080 if (binding
&& binding
->scope
== class_binding_level
)
3081 /* Supplement the existing binding. */
3082 ok
= supplement_binding (binding
, decl
);
3085 /* Create a new binding. */
3086 push_binding (name
, decl
, class_binding_level
);
3093 /* Wrapper for push_class_level_binding_1. */
3096 push_class_level_binding (tree name
, tree x
)
3099 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3100 ret
= push_class_level_binding_1 (name
, x
);
3101 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3105 /* Process "using SCOPE::NAME" in a class scope. Return the
3106 USING_DECL created. */
3109 do_class_using_decl (tree scope
, tree name
)
3111 /* The USING_DECL returned by this function. */
3113 /* The declaration (or declarations) name by this using
3114 declaration. NULL if we are in a template and cannot figure out
3115 what has been named. */
3117 /* True if SCOPE is a dependent type. */
3118 bool scope_dependent_p
;
3119 /* True if SCOPE::NAME is dependent. */
3120 bool name_dependent_p
;
3121 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3122 bool bases_dependent_p
;
3127 if (name
== error_mark_node
)
3130 if (!scope
|| !TYPE_P (scope
))
3132 error ("using-declaration for non-member at class scope");
3136 /* Make sure the name is not invalid */
3137 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
3139 error ("%<%T::%D%> names destructor", scope
, name
);
3142 if (MAYBE_CLASS_TYPE_P (scope
) && constructor_name_p (name
, scope
))
3144 error ("%<%T::%D%> names constructor", scope
, name
);
3147 if (constructor_name_p (name
, current_class_type
))
3149 error ("%<%T::%D%> names constructor in %qT",
3150 scope
, name
, current_class_type
);
3154 scope_dependent_p
= dependent_type_p (scope
);
3155 name_dependent_p
= (scope_dependent_p
3156 || (IDENTIFIER_TYPENAME_P (name
)
3157 && dependent_type_p (TREE_TYPE (name
))));
3159 bases_dependent_p
= false;
3160 if (processing_template_decl
)
3161 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3162 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
3164 if (dependent_type_p (TREE_TYPE (base_binfo
)))
3166 bases_dependent_p
= true;
3172 /* From [namespace.udecl]:
3174 A using-declaration used as a member-declaration shall refer to a
3175 member of a base class of the class being defined.
3177 In general, we cannot check this constraint in a template because
3178 we do not know the entire set of base classes of the current
3179 class type. However, if all of the base classes are
3180 non-dependent, then we can avoid delaying the check until
3182 if (!scope_dependent_p
)
3185 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
3186 if (b_kind
< bk_proper_base
)
3188 if (!bases_dependent_p
)
3190 error_not_base_type (scope
, current_class_type
);
3194 else if (!name_dependent_p
)
3196 decl
= lookup_member (binfo
, name
, 0, false);
3199 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
3203 /* The binfo from which the functions came does not matter. */
3204 if (BASELINK_P (decl
))
3205 decl
= BASELINK_FUNCTIONS (decl
);
3209 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3210 USING_DECL_DECLS (value
) = decl
;
3211 USING_DECL_SCOPE (value
) = scope
;
3212 DECL_DEPENDENT_P (value
) = !decl
;
3218 /* Return the binding value for name in scope. */
3222 namespace_binding_1 (tree name
, tree scope
)
3224 cxx_binding
*binding
;
3226 if (SCOPE_FILE_SCOPE_P (scope
))
3227 scope
= global_namespace
;
3229 /* Unnecessary for the global namespace because it can't be an alias. */
3230 scope
= ORIGINAL_NAMESPACE (scope
);
3232 binding
= cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3234 return binding
? binding
->value
: NULL_TREE
;
3238 namespace_binding (tree name
, tree scope
)
3241 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3242 ret
= namespace_binding_1 (name
, scope
);
3243 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3247 /* Set the binding value for name in scope. */
3250 set_namespace_binding_1 (tree name
, tree scope
, tree val
)
3254 if (scope
== NULL_TREE
)
3255 scope
= global_namespace
;
3256 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3257 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3260 supplement_binding (b
, val
);
3263 /* Wrapper for set_namespace_binding_1. */
3266 set_namespace_binding (tree name
, tree scope
, tree val
)
3268 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3269 set_namespace_binding_1 (name
, scope
, val
);
3270 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3273 /* Set the context of a declaration to scope. Complain if we are not
3277 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3281 /* Get rid of namespace aliases. */
3282 scope
= ORIGINAL_NAMESPACE (scope
);
3284 /* It is ok for friends to be qualified in parallel space. */
3285 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3286 error ("declaration of %qD not in a namespace surrounding %qD",
3288 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3290 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3291 if (scope
== current_namespace
)
3293 if (at_namespace_scope_p ())
3294 error ("explicit qualification in declaration of %qD",
3299 /* See whether this has been declared in the namespace. */
3300 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3301 if (old
== error_mark_node
)
3302 /* No old declaration at all. */
3304 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3305 if (TREE_CODE (old
) == TREE_LIST
)
3307 error ("reference to %qD is ambiguous", decl
);
3308 print_candidates (old
);
3311 if (!is_overloaded_fn (decl
))
3313 /* We might have found OLD in an inline namespace inside SCOPE. */
3314 if (TREE_CODE (decl
) == TREE_CODE (old
))
3315 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3316 /* Don't compare non-function decls with decls_match here, since
3317 it can't check for the correct constness at this
3318 point. pushdecl will find those errors later. */
3321 /* Since decl is a function, old should contain a function decl. */
3322 if (!is_overloaded_fn (old
))
3324 /* A template can be explicitly specialized in any namespace. */
3325 if (processing_explicit_instantiation
)
3327 if (processing_template_decl
|| processing_specialization
)
3328 /* We have not yet called push_template_decl to turn a
3329 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3330 match. But, we'll check later, when we construct the
3333 /* Instantiations or specializations of templates may be declared as
3334 friends in any namespace. */
3335 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3337 if (is_overloaded_fn (old
))
3339 tree found
= NULL_TREE
;
3341 for (; elt
; elt
= OVL_NEXT (elt
))
3343 tree ofn
= OVL_CURRENT (elt
);
3344 /* Adjust DECL_CONTEXT first so decls_match will return true
3345 if DECL will match a declaration in an inline namespace. */
3346 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
3347 if (decls_match (decl
, ofn
))
3349 if (found
&& !decls_match (found
, ofn
))
3351 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3352 error ("reference to %qD is ambiguous", decl
);
3353 print_candidates (old
);
3361 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (found
)))
3363 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
3369 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3370 if (decls_match (decl
, old
))
3374 /* It didn't work, go back to the explicit scope. */
3375 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3377 error ("%qD should have been declared inside %qD", decl
, scope
);
3380 /* Return the namespace where the current declaration is declared. */
3383 current_decl_namespace (void)
3386 /* If we have been pushed into a different namespace, use it. */
3387 if (!VEC_empty (tree
, decl_namespace_list
))
3388 return VEC_last (tree
, decl_namespace_list
);
3390 if (current_class_type
)
3391 result
= decl_namespace_context (current_class_type
);
3392 else if (current_function_decl
)
3393 result
= decl_namespace_context (current_function_decl
);
3395 result
= current_namespace
;
3399 /* Process any ATTRIBUTES on a namespace definition. Currently only
3400 attribute visibility is meaningful, which is a property of the syntactic
3401 block rather than the namespace as a whole, so we don't touch the
3402 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3405 handle_namespace_attrs (tree ns
, tree attributes
)
3408 bool saw_vis
= false;
3410 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3412 tree name
= TREE_PURPOSE (d
);
3413 tree args
= TREE_VALUE (d
);
3415 if (is_attribute_p ("visibility", name
))
3417 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3418 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3420 warning (OPT_Wattributes
,
3421 "%qD attribute requires a single NTBS argument",
3426 if (!TREE_PUBLIC (ns
))
3427 warning (OPT_Wattributes
,
3428 "%qD attribute is meaningless since members of the "
3429 "anonymous namespace get local symbols", name
);
3431 push_visibility (TREE_STRING_POINTER (x
), 1);
3436 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3445 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3446 select a name that is unique to this compilation unit. */
3449 push_namespace (tree name
)
3453 int implicit_use
= 0;
3456 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3458 /* We should not get here if the global_namespace is not yet constructed
3459 nor if NAME designates the global namespace: The global scope is
3460 constructed elsewhere. */
3461 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3465 name
= get_anonymous_namespace_name();
3466 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3468 /* Reopening anonymous namespace. */
3474 /* Check whether this is an extended namespace definition. */
3475 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3476 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3479 if (DECL_NAMESPACE_ALIAS (d
))
3481 error ("namespace alias %qD not allowed here, assuming %qD",
3482 d
, DECL_NAMESPACE_ALIAS (d
));
3483 d
= DECL_NAMESPACE_ALIAS (d
);
3490 /* Make a new namespace, binding the name to it. */
3491 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3492 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3493 /* The name of this namespace is not visible to other translation
3494 units if it is an anonymous namespace or member thereof. */
3495 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3496 TREE_PUBLIC (d
) = 0;
3498 TREE_PUBLIC (d
) = 1;
3502 /* Clear DECL_NAME for the benefit of debugging back ends. */
3503 SET_DECL_ASSEMBLER_NAME (d
, name
);
3504 DECL_NAME (d
) = NULL_TREE
;
3506 begin_scope (sk_namespace
, d
);
3509 resume_scope (NAMESPACE_LEVEL (d
));
3512 do_using_directive (d
);
3513 /* Enter the name space. */
3514 current_namespace
= d
;
3516 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3519 /* Pop from the scope of the current namespace. */
3522 pop_namespace (void)
3524 gcc_assert (current_namespace
!= global_namespace
);
3525 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3526 /* The binding level is not popped, as it might be re-opened later. */
3530 /* Push into the scope of the namespace NS, even if it is deeply
3531 nested within another namespace. */
3534 push_nested_namespace (tree ns
)
3536 if (ns
== global_namespace
)
3537 push_to_top_level ();
3540 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3541 push_namespace (DECL_NAME (ns
));
3545 /* Pop back from the scope of the namespace NS, which was previously
3546 entered with push_nested_namespace. */
3549 pop_nested_namespace (tree ns
)
3551 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3552 gcc_assert (current_namespace
== ns
);
3553 while (ns
!= global_namespace
)
3556 ns
= CP_DECL_CONTEXT (ns
);
3559 pop_from_top_level ();
3560 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3563 /* Temporarily set the namespace for the current declaration. */
3566 push_decl_namespace (tree decl
)
3568 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3569 decl
= decl_namespace_context (decl
);
3570 VEC_safe_push (tree
, gc
, decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
3573 /* [namespace.memdef]/2 */
3576 pop_decl_namespace (void)
3578 VEC_pop (tree
, decl_namespace_list
);
3581 /* Return the namespace that is the common ancestor
3582 of two given namespaces. */
3585 namespace_ancestor_1 (tree ns1
, tree ns2
)
3588 if (is_ancestor (ns1
, ns2
))
3591 nsr
= namespace_ancestor_1 (CP_DECL_CONTEXT (ns1
), ns2
);
3595 /* Wrapper for namespace_ancestor_1. */
3598 namespace_ancestor (tree ns1
, tree ns2
)
3601 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3602 nsr
= namespace_ancestor_1 (ns1
, ns2
);
3603 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3607 /* Process a namespace-alias declaration. */
3610 do_namespace_alias (tree alias
, tree name_space
)
3612 if (name_space
== error_mark_node
)
3615 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3617 name_space
= ORIGINAL_NAMESPACE (name_space
);
3619 /* Build the alias. */
3620 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3621 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3622 DECL_EXTERNAL (alias
) = 1;
3623 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3626 /* Emit debug info for namespace alias. */
3627 if (!building_stmt_list_p ())
3628 (*debug_hooks
->global_decl
) (alias
);
3631 /* Like pushdecl, only it places X in the current namespace,
3635 pushdecl_namespace_level (tree x
, bool is_friend
)
3637 cp_binding_level
*b
= current_binding_level
;
3640 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3641 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3643 /* Now, the type_shadowed stack may screw us. Munge it so it does
3645 if (TREE_CODE (t
) == TYPE_DECL
)
3647 tree name
= DECL_NAME (t
);
3649 tree
*ptr
= (tree
*)0;
3650 for (; !global_scope_p (b
); b
= b
->level_chain
)
3652 tree shadowed
= b
->type_shadowed
;
3653 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3654 if (TREE_PURPOSE (shadowed
) == name
)
3656 ptr
= &TREE_VALUE (shadowed
);
3657 /* Can't break out of the loop here because sometimes
3658 a binding level will have duplicate bindings for
3659 PT names. It's gross, but I haven't time to fix it. */
3662 newval
= TREE_TYPE (t
);
3663 if (ptr
== (tree
*)0)
3665 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3666 up here if this is changed to an assertion. --KR */
3667 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3674 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3678 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3679 directive is not directly from the source. Also find the common
3680 ancestor and let our users know about the new namespace */
3683 add_using_namespace_1 (tree user
, tree used
, bool indirect
)
3686 /* Using oneself is a no-op. */
3689 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3690 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3691 /* Check if we already have this. */
3692 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3696 /* Promote to direct usage. */
3697 TREE_INDIRECT_USING (t
) = 0;
3701 /* Add used to the user's using list. */
3702 DECL_NAMESPACE_USING (user
)
3703 = tree_cons (used
, namespace_ancestor (user
, used
),
3704 DECL_NAMESPACE_USING (user
));
3706 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3708 /* Add user to the used's users list. */
3709 DECL_NAMESPACE_USERS (used
)
3710 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3712 /* Recursively add all namespaces used. */
3713 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3714 /* indirect usage */
3715 add_using_namespace_1 (user
, TREE_PURPOSE (t
), 1);
3717 /* Tell everyone using us about the new used namespaces. */
3718 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3719 add_using_namespace_1 (TREE_PURPOSE (t
), used
, 1);
3722 /* Wrapper for add_using_namespace_1. */
3725 add_using_namespace (tree user
, tree used
, bool indirect
)
3727 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3728 add_using_namespace_1 (user
, used
, indirect
);
3729 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3732 /* Process a using-declaration not appearing in class or local scope. */
3735 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3737 tree oldval
, oldtype
, newval
, newtype
;
3738 tree orig_decl
= decl
;
3739 cxx_binding
*binding
;
3741 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3742 if (decl
== NULL_TREE
)
3745 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3747 oldval
= binding
->value
;
3748 oldtype
= binding
->type
;
3750 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3752 /* Emit debug info. */
3753 if (!processing_template_decl
)
3754 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3756 /* Copy declarations found. */
3758 binding
->value
= newval
;
3760 binding
->type
= newtype
;
3763 /* Process a using-directive. */
3766 do_using_directive (tree name_space
)
3768 tree context
= NULL_TREE
;
3770 if (name_space
== error_mark_node
)
3773 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3775 if (building_stmt_list_p ())
3776 add_stmt (build_stmt (input_location
, USING_STMT
, name_space
));
3777 name_space
= ORIGINAL_NAMESPACE (name_space
);
3779 if (!toplevel_bindings_p ())
3781 push_using_directive (name_space
);
3786 add_using_namespace (current_namespace
, name_space
, 0);
3787 if (current_namespace
!= global_namespace
)
3788 context
= current_namespace
;
3790 /* Emit debugging info. */
3791 if (!processing_template_decl
)
3792 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
3797 /* Deal with a using-directive seen by the parser. Currently we only
3798 handle attributes here, since they cannot appear inside a template. */
3801 parse_using_directive (tree name_space
, tree attribs
)
3805 do_using_directive (name_space
);
3807 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3809 tree name
= TREE_PURPOSE (a
);
3810 if (is_attribute_p ("strong", name
))
3812 if (!toplevel_bindings_p ())
3813 error ("strong using only meaningful at namespace scope");
3814 else if (name_space
!= error_mark_node
)
3816 if (!is_ancestor (current_namespace
, name_space
))
3817 error ("current namespace %qD does not enclose strongly used namespace %qD",
3818 current_namespace
, name_space
);
3819 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
3820 = tree_cons (current_namespace
, 0,
3821 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
3825 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3829 /* Like pushdecl, only it places X in the global scope if appropriate.
3830 Calls cp_finish_decl to register the variable, initializing it with
3831 *INIT, if INIT is non-NULL. */
3834 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3836 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3837 push_to_top_level ();
3838 x
= pushdecl_namespace_level (x
, is_friend
);
3840 cp_finish_decl (x
, *init
, false, NULL_TREE
, 0);
3841 pop_from_top_level ();
3842 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3846 /* Like pushdecl, only it places X in the global scope if appropriate. */
3849 pushdecl_top_level (tree x
)
3851 return pushdecl_top_level_1 (x
, NULL
, false);
3854 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3857 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3859 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3862 /* Like pushdecl, only it places X in the global scope if
3863 appropriate. Calls cp_finish_decl to register the variable,
3864 initializing it with INIT. */
3867 pushdecl_top_level_and_finish (tree x
, tree init
)
3869 return pushdecl_top_level_1 (x
, &init
, false);
3872 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3873 duplicates. The first list becomes the tail of the result.
3875 The algorithm is O(n^2). We could get this down to O(n log n) by
3876 doing a sort on the addresses of the functions, if that becomes
3880 merge_functions (tree s1
, tree s2
)
3882 for (; s2
; s2
= OVL_NEXT (s2
))
3884 tree fn2
= OVL_CURRENT (s2
);
3887 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3889 tree fn1
= OVL_CURRENT (fns1
);
3891 /* If the function from S2 is already in S1, there is no
3892 need to add it again. For `extern "C"' functions, we
3893 might have two FUNCTION_DECLs for the same function, in
3894 different namespaces, but let's leave them in in case
3895 they have different default arguments. */
3900 /* If we exhausted all of the functions in S1, FN2 is new. */
3902 s1
= build_overload (fn2
, s1
);
3907 /* Returns TRUE iff OLD and NEW are the same entity.
3909 3 [basic]/3: An entity is a value, object, reference, function,
3910 enumerator, type, class member, template, template specialization,
3911 namespace, parameter pack, or this.
3913 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
3914 in two different namespaces, and the declarations do not declare the
3915 same entity and do not declare functions, the use of the name is
3919 same_entity_p (tree one
, tree two
)
3925 if (TREE_CODE (one
) == TYPE_DECL
3926 && TREE_CODE (two
) == TYPE_DECL
3927 && same_type_p (TREE_TYPE (one
), TREE_TYPE (two
)))
3932 /* This should return an error not all definitions define functions.
3933 It is not an error if we find two functions with exactly the
3934 same signature, only if these are selected in overload resolution.
3935 old is the current set of bindings, new_binding the freshly-found binding.
3936 XXX Do we want to give *all* candidates in case of ambiguity?
3937 XXX In what way should I treat extern declarations?
3938 XXX I don't want to repeat the entire duplicate_decls here */
3941 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
3944 gcc_assert (old
!= NULL
);
3946 /* Copy the type. */
3947 type
= new_binding
->type
;
3948 if (LOOKUP_NAMESPACES_ONLY (flags
)
3949 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
3952 /* Copy the value. */
3953 val
= new_binding
->value
;
3956 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
3959 switch (TREE_CODE (val
))
3962 /* If we expect types or namespaces, and not templates,
3963 or this is not a template class. */
3964 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3965 && !DECL_CLASS_TEMPLATE_P (val
)))
3969 if (LOOKUP_NAMESPACES_ONLY (flags
)
3970 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
3973 case NAMESPACE_DECL
:
3974 if (LOOKUP_TYPES_ONLY (flags
))
3978 /* Ignore built-in functions that are still anticipated. */
3979 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3983 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3988 /* If val is hidden, shift down any class or enumeration name. */
3997 else if (val
&& !same_entity_p (val
, old
->value
))
3999 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
4000 old
->value
= merge_functions (old
->value
, val
);
4003 old
->value
= tree_cons (NULL_TREE
, old
->value
,
4004 build_tree_list (NULL_TREE
, val
));
4005 TREE_TYPE (old
->value
) = error_mark_node
;
4011 else if (type
&& old
->type
!= type
)
4013 old
->type
= tree_cons (NULL_TREE
, old
->type
,
4014 build_tree_list (NULL_TREE
, type
));
4015 TREE_TYPE (old
->type
) = error_mark_node
;
4019 /* Return the declarations that are members of the namespace NS. */
4022 cp_namespace_decls (tree ns
)
4024 return NAMESPACE_LEVEL (ns
)->names
;
4027 /* Combine prefer_type and namespaces_only into flags. */
4030 lookup_flags (int prefer_type
, int namespaces_only
)
4032 if (namespaces_only
)
4033 return LOOKUP_PREFER_NAMESPACES
;
4034 if (prefer_type
> 1)
4035 return LOOKUP_PREFER_TYPES
;
4036 if (prefer_type
> 0)
4037 return LOOKUP_PREFER_BOTH
;
4041 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4042 ignore it or not. Subroutine of lookup_name_real and
4043 lookup_type_scope. */
4046 qualify_lookup (tree val
, int flags
)
4048 if (val
== NULL_TREE
)
4050 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
4052 if ((flags
& LOOKUP_PREFER_TYPES
)
4053 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
4055 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
4057 /* Look through lambda things that we shouldn't be able to see. */
4058 if (is_lambda_ignored_entity (val
))
4063 /* Given a lookup that returned VAL, decide if we want to ignore it or
4064 not based on DECL_ANTICIPATED. */
4067 hidden_name_p (tree val
)
4070 && DECL_LANG_SPECIFIC (val
)
4071 && DECL_ANTICIPATED (val
))
4076 /* Remove any hidden friend functions from a possibly overloaded set
4080 remove_hidden_names (tree fns
)
4085 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
4087 else if (TREE_CODE (fns
) == OVERLOAD
)
4091 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4092 if (hidden_name_p (OVL_CURRENT (o
)))
4098 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4099 if (!hidden_name_p (OVL_CURRENT (o
)))
4100 n
= build_overload (OVL_CURRENT (o
), n
);
4108 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4109 lookup failed. Search through all available namespaces and print out
4110 possible candidates. */
4113 suggest_alternatives_for (location_t location
, tree name
)
4115 VEC(tree
,heap
) *candidates
= NULL
;
4116 VEC(tree
,heap
) *namespaces_to_search
= NULL
;
4117 int max_to_search
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
4122 VEC_safe_push (tree
, heap
, namespaces_to_search
, global_namespace
);
4124 while (!VEC_empty (tree
, namespaces_to_search
)
4125 && n_searched
< max_to_search
)
4127 tree scope
= VEC_pop (tree
, namespaces_to_search
);
4128 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4129 cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
4131 /* Look in this namespace. */
4132 qualified_lookup_using_namespace (name
, scope
, &binding
, 0);
4137 VEC_safe_push (tree
, heap
, candidates
, binding
.value
);
4139 /* Add child namespaces. */
4140 for (t
= level
->namespaces
; t
; t
= DECL_CHAIN (t
))
4141 VEC_safe_push (tree
, heap
, namespaces_to_search
, t
);
4144 /* If we stopped before we could examine all namespaces, inform the
4145 user. Do this even if we don't have any candidates, since there
4146 might be more candidates further down that we weren't able to
4148 if (n_searched
>= max_to_search
4149 && !VEC_empty (tree
, namespaces_to_search
))
4151 "maximum limit of %d namespaces searched for %qE",
4152 max_to_search
, name
);
4154 VEC_free (tree
, heap
, namespaces_to_search
);
4156 /* Nothing useful to report. */
4157 if (VEC_empty (tree
, candidates
))
4160 inform_n (location
, VEC_length (tree
, candidates
),
4161 "suggested alternative:",
4162 "suggested alternatives:");
4164 FOR_EACH_VEC_ELT (tree
, candidates
, ix
, t
)
4165 inform (location_of (t
), " %qE", t
);
4167 VEC_free (tree
, heap
, candidates
);
4170 /* Unscoped lookup of a global: iterate over current namespaces,
4171 considering using-directives. */
4174 unqualified_namespace_lookup_1 (tree name
, int flags
)
4176 tree initial
= current_decl_namespace ();
4177 tree scope
= initial
;
4179 cp_binding_level
*level
;
4180 tree val
= NULL_TREE
;
4182 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
4184 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4186 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4189 ambiguous_decl (&binding
, b
, flags
);
4191 /* Add all _DECLs seen through local using-directives. */
4192 for (level
= current_binding_level
;
4193 level
->kind
!= sk_namespace
;
4194 level
= level
->level_chain
)
4195 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
4197 /* Give up because of error. */
4198 return error_mark_node
;
4200 /* Add all _DECLs seen through global using-directives. */
4201 /* XXX local and global using lists should work equally. */
4205 if (!lookup_using_namespace (name
, &binding
,
4206 DECL_NAMESPACE_USING (siter
),
4208 /* Give up because of error. */
4209 return error_mark_node
;
4210 if (siter
== scope
) break;
4211 siter
= CP_DECL_CONTEXT (siter
);
4214 val
= binding
.value
;
4215 if (scope
== global_namespace
)
4221 /* Wrapper for unqualified_namespace_lookup_1. */
4224 unqualified_namespace_lookup (tree name
, int flags
)
4227 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4228 ret
= unqualified_namespace_lookup_1 (name
, flags
);
4229 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4233 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4234 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4237 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4238 declaration found. If no suitable declaration can be found,
4239 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4240 neither a class-type nor a namespace a diagnostic is issued. */
4243 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
4248 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
4250 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4252 flags
|= LOOKUP_COMPLAIN
;
4254 flags
|= LOOKUP_PREFER_TYPES
;
4255 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
4258 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
4259 t
= lookup_enumerator (scope
, name
);
4260 else if (is_class_type (scope
, complain
))
4261 t
= lookup_member (scope
, name
, 2, is_type_p
);
4264 return error_mark_node
;
4268 /* Subroutine of unqualified_namespace_lookup:
4269 Add the bindings of NAME in used namespaces to VAL.
4270 We are currently looking for names in namespace SCOPE, so we
4271 look through USINGS for using-directives of namespaces
4272 which have SCOPE as a common ancestor with the current scope.
4273 Returns false on errors. */
4276 lookup_using_namespace (tree name
, struct scope_binding
*val
,
4277 tree usings
, tree scope
, int flags
)
4280 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4281 /* Iterate over all used namespaces in current, searching for using
4282 directives of scope. */
4283 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
4284 if (TREE_VALUE (iter
) == scope
)
4286 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
4288 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
4289 /* Resolve ambiguities. */
4291 ambiguous_decl (val
, val1
, flags
);
4293 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4294 return val
->value
!= error_mark_node
;
4297 /* Returns true iff VEC contains TARGET. */
4300 tree_vec_contains (VEC(tree
,gc
)* vec
, tree target
)
4304 FOR_EACH_VEC_ELT (tree
,vec
,i
,elt
)
4311 Accepts the NAME to lookup and its qualifying SCOPE.
4312 Returns the name/type pair found into the cxx_binding *RESULT,
4313 or false on error. */
4316 qualified_lookup_using_namespace (tree name
, tree scope
,
4317 struct scope_binding
*result
, int flags
)
4319 /* Maintain a list of namespaces visited... */
4320 VEC(tree
,gc
) *seen
= NULL
;
4321 VEC(tree
,gc
) *seen_inline
= NULL
;
4322 /* ... and a list of namespace yet to see. */
4323 VEC(tree
,gc
) *todo
= NULL
;
4324 VEC(tree
,gc
) *todo_maybe
= NULL
;
4325 VEC(tree
,gc
) *todo_inline
= NULL
;
4327 timevar_start (TV_NAME_LOOKUP
);
4328 /* Look through namespace aliases. */
4329 scope
= ORIGINAL_NAMESPACE (scope
);
4331 /* Algorithm: Starting with SCOPE, walk through the set of used
4332 namespaces. For each used namespace, look through its inline
4333 namespace set for any bindings and usings. If no bindings are
4334 found, add any usings seen to the set of used namespaces. */
4335 VEC_safe_push (tree
, gc
, todo
, scope
);
4337 while (VEC_length (tree
, todo
))
4340 scope
= VEC_pop (tree
, todo
);
4341 if (tree_vec_contains (seen
, scope
))
4343 VEC_safe_push (tree
, gc
, seen
, scope
);
4344 VEC_safe_push (tree
, gc
, todo_inline
, scope
);
4347 while (VEC_length (tree
, todo_inline
))
4349 cxx_binding
*binding
;
4351 scope
= VEC_pop (tree
, todo_inline
);
4352 if (tree_vec_contains (seen_inline
, scope
))
4354 VEC_safe_push (tree
, gc
, seen_inline
, scope
);
4357 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4361 ambiguous_decl (result
, binding
, flags
);
4364 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
4365 usings
= TREE_CHAIN (usings
))
4366 if (!TREE_INDIRECT_USING (usings
))
4368 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
)))
4369 VEC_safe_push (tree
, gc
, todo_inline
, TREE_PURPOSE (usings
));
4371 VEC_safe_push (tree
, gc
, todo_maybe
, TREE_PURPOSE (usings
));
4376 VEC_truncate (tree
, todo_maybe
, 0);
4378 while (VEC_length (tree
, todo_maybe
))
4379 VEC_safe_push (tree
, gc
, todo
, VEC_pop (tree
, todo_maybe
));
4381 VEC_free (tree
,gc
,todo
);
4382 VEC_free (tree
,gc
,todo_maybe
);
4383 VEC_free (tree
,gc
,todo_inline
);
4384 VEC_free (tree
,gc
,seen
);
4385 VEC_free (tree
,gc
,seen_inline
);
4386 timevar_stop (TV_NAME_LOOKUP
);
4387 return result
->value
!= error_mark_node
;
4390 /* Subroutine of outer_binding.
4392 Returns TRUE if BINDING is a binding to a template parameter of
4393 SCOPE. In that case SCOPE is the scope of a primary template
4394 parameter -- in the sense of G++, i.e, a template that has its own
4397 Returns FALSE otherwise. */
4400 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
4401 cp_binding_level
*scope
)
4405 if (!binding
|| !scope
)
4408 binding_value
= binding
->value
? binding
->value
: binding
->type
;
4411 && scope
->this_entity
4412 && get_template_info (scope
->this_entity
)
4413 && PRIMARY_TEMPLATE_P (TI_TEMPLATE
4414 (get_template_info (scope
->this_entity
)))
4415 && parameter_of_template_p (binding_value
,
4416 TI_TEMPLATE (get_template_info \
4417 (scope
->this_entity
))));
4420 /* Return the innermost non-namespace binding for NAME from a scope
4421 containing BINDING, or, if BINDING is NULL, the current scope.
4422 Please note that for a given template, the template parameters are
4423 considered to be in the scope containing the current scope.
4424 If CLASS_P is false, then class bindings are ignored. */
4427 outer_binding (tree name
,
4428 cxx_binding
*binding
,
4432 cp_binding_level
*scope
;
4433 cp_binding_level
*outer_scope
;
4437 scope
= binding
->scope
->level_chain
;
4438 outer
= binding
->previous
;
4442 scope
= current_binding_level
;
4443 outer
= IDENTIFIER_BINDING (name
);
4445 outer_scope
= outer
? outer
->scope
: NULL
;
4447 /* Because we create class bindings lazily, we might be missing a
4448 class binding for NAME. If there are any class binding levels
4449 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4450 declared, we must lookup NAME in those class scopes. */
4452 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4454 if (scope
->kind
== sk_class
)
4456 cxx_binding
*class_binding
;
4458 class_binding
= get_class_binding (name
, scope
);
4461 /* Thread this new class-scope binding onto the
4462 IDENTIFIER_BINDING list so that future lookups
4464 class_binding
->previous
= outer
;
4466 binding
->previous
= class_binding
;
4468 IDENTIFIER_BINDING (name
) = class_binding
;
4469 return class_binding
;
4472 /* If we are in a member template, the template parms of the member
4473 template are considered to be inside the scope of the containing
4474 class, but within G++ the class bindings are all pushed between the
4475 template parms and the function body. So if the outer binding is
4476 a template parm for the current scope, return it now rather than
4477 look for a class binding. */
4478 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4479 && binding_to_template_parms_of_scope_p (outer
, scope
))
4482 scope
= scope
->level_chain
;
4488 /* Return the innermost block-scope or class-scope value binding for
4489 NAME, or NULL_TREE if there is no such binding. */
4492 innermost_non_namespace_value (tree name
)
4494 cxx_binding
*binding
;
4495 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4496 return binding
? binding
->value
: NULL_TREE
;
4499 /* Look up NAME in the current binding level and its superiors in the
4500 namespace of variables, functions and typedefs. Return a ..._DECL
4501 node of some kind representing its definition if there is only one
4502 such declaration, or return a TREE_LIST with all the overloaded
4503 definitions if there are many, or return 0 if it is undefined.
4504 Hidden name, either friend declaration or built-in function, are
4507 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4508 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4509 Otherwise we prefer non-TYPE_DECLs.
4511 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4512 BLOCK_P is false, bindings in block scopes are ignored. */
4515 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4516 int namespaces_only
, int flags
)
4519 tree val
= NULL_TREE
;
4521 /* Conversion operators are handled specially because ordinary
4522 unqualified name lookup will not find template conversion
4524 if (IDENTIFIER_TYPENAME_P (name
))
4526 cp_binding_level
*level
;
4528 for (level
= current_binding_level
;
4529 level
&& level
->kind
!= sk_namespace
;
4530 level
= level
->level_chain
)
4535 /* A conversion operator can only be declared in a class
4537 if (level
->kind
!= sk_class
)
4540 /* Lookup the conversion operator in the class. */
4541 class_type
= level
->this_entity
;
4542 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4550 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4552 /* First, look in non-namespace scopes. */
4554 if (current_class_type
== NULL_TREE
)
4557 if (block_p
|| !nonclass
)
4558 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4560 iter
= outer_binding (name
, iter
, !nonclass
))
4564 /* Skip entities we don't want. */
4565 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4568 /* If this is the kind of thing we're looking for, we're done. */
4569 if (qualify_lookup (iter
->value
, flags
))
4570 binding
= iter
->value
;
4571 else if ((flags
& LOOKUP_PREFER_TYPES
)
4572 && qualify_lookup (iter
->type
, flags
))
4573 binding
= iter
->type
;
4575 binding
= NULL_TREE
;
4579 if (hidden_name_p (binding
))
4581 /* A non namespace-scope binding can only be hidden in the
4582 presence of a local class, due to friend declarations.
4584 In particular, consider:
4592 B* b; // error: B is hidden
4593 C* c; // OK, finds ::C
4596 B *b; // error: B is hidden
4597 C *c; // OK, finds ::C
4602 The standard says that "B" is a local class in "f"
4603 (but not nested within "A") -- but that name lookup
4604 for "B" does not find this declaration until it is
4605 declared directly with "f".
4611 If a friend declaration appears in a local class and
4612 the name specified is an unqualified name, a prior
4613 declaration is looked up without considering scopes
4614 that are outside the innermost enclosing non-class
4615 scope. For a friend function declaration, if there is
4616 no prior declaration, the program is ill-formed. For a
4617 friend class declaration, if there is no prior
4618 declaration, the class that is specified belongs to the
4619 innermost enclosing non-class scope, but if it is
4620 subsequently referenced, its name is not found by name
4621 lookup until a matching declaration is provided in the
4622 innermost enclosing nonclass scope.
4624 So just keep looking for a non-hidden binding.
4626 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4634 /* Now lookup in namespace scopes. */
4636 val
= unqualified_namespace_lookup (name
, flags
);
4638 /* If we have a single function from a using decl, pull it out. */
4639 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4640 val
= OVL_FUNCTION (val
);
4645 /* Wrapper for lookup_name_real_1. */
4648 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4649 int namespaces_only
, int flags
)
4652 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4653 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
4654 namespaces_only
, flags
);
4655 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4660 lookup_name_nonclass (tree name
)
4662 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4666 lookup_function_nonclass (tree name
, VEC(tree
,gc
) *args
, bool block_p
)
4669 lookup_arg_dependent (name
,
4670 lookup_name_real (name
, 0, 1, block_p
, 0,
4676 lookup_name (tree name
)
4678 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4682 lookup_name_prefer_type (tree name
, int prefer_type
)
4684 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
4685 0, LOOKUP_COMPLAIN
);
4688 /* Look up NAME for type used in elaborated name specifier in
4689 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4690 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4691 name, more scopes are checked if cleanup or template parameter
4692 scope is encountered.
4694 Unlike lookup_name_real, we make sure that NAME is actually
4695 declared in the desired scope, not from inheritance, nor using
4696 directive. For using declaration, there is DR138 still waiting
4697 to be resolved. Hidden name coming from an earlier friend
4698 declaration is also returned.
4700 A TYPE_DECL best matching the NAME is returned. Catching error
4701 and issuing diagnostics are caller's responsibility. */
4704 lookup_type_scope_1 (tree name
, tag_scope scope
)
4706 cxx_binding
*iter
= NULL
;
4707 tree val
= NULL_TREE
;
4709 /* Look in non-namespace scope first. */
4710 if (current_binding_level
->kind
!= sk_namespace
)
4711 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4712 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4714 /* Check if this is the kind of thing we're looking for.
4715 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4716 base class. For ITER->VALUE, we can simply use
4717 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4720 We check ITER->TYPE before ITER->VALUE in order to handle
4721 typedef struct C {} C;
4724 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4725 && (scope
!= ts_current
4726 || LOCAL_BINDING_P (iter
)
4727 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4729 else if ((scope
!= ts_current
4730 || !INHERITED_VALUE_BINDING_P (iter
))
4731 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4738 /* Look in namespace scope. */
4741 iter
= cp_binding_level_find_binding_for_name
4742 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4746 /* If this is the kind of thing we're looking for, we're done. */
4747 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4749 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4755 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4756 and template parameter scopes. */
4759 cp_binding_level
*b
= current_binding_level
;
4762 if (iter
->scope
== b
)
4765 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
4766 || b
->kind
== sk_function_parms
)
4768 else if (b
->kind
== sk_class
4769 && scope
== ts_within_enclosing_non_class
)
4779 /* Wrapper for lookup_type_scope_1. */
4782 lookup_type_scope (tree name
, tag_scope scope
)
4785 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4786 ret
= lookup_type_scope_1 (name
, scope
);
4787 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4792 /* Similar to `lookup_name' but look only in the innermost non-class
4796 lookup_name_innermost_nonclass_level_1 (tree name
)
4798 cp_binding_level
*b
;
4801 b
= innermost_nonclass_level ();
4803 if (b
->kind
== sk_namespace
)
4805 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4807 /* extern "C" function() */
4808 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4811 else if (IDENTIFIER_BINDING (name
)
4812 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4814 cxx_binding
*binding
;
4815 binding
= IDENTIFIER_BINDING (name
);
4818 if (binding
->scope
== b
4819 && !(TREE_CODE (binding
->value
) == VAR_DECL
4820 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4821 return binding
->value
;
4823 if (b
->kind
== sk_cleanup
)
4833 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
4836 lookup_name_innermost_nonclass_level (tree name
)
4839 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4840 ret
= lookup_name_innermost_nonclass_level_1 (name
);
4841 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4846 /* Returns true iff DECL is a block-scope extern declaration of a function
4850 is_local_extern (tree decl
)
4852 cxx_binding
*binding
;
4854 /* For functions, this is easy. */
4855 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4856 return DECL_LOCAL_FUNCTION_P (decl
);
4858 if (TREE_CODE (decl
) != VAR_DECL
)
4860 if (!current_function_decl
)
4863 /* For variables, this is not easy. We need to look at the binding stack
4864 for the identifier to see whether the decl we have is a local. */
4865 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
4866 binding
&& binding
->scope
->kind
!= sk_namespace
;
4867 binding
= binding
->previous
)
4868 if (binding
->value
== decl
)
4869 return LOCAL_BINDING_P (binding
);
4874 /* Like lookup_name_innermost_nonclass_level, but for types. */
4877 lookup_type_current_level (tree name
)
4881 timevar_start (TV_NAME_LOOKUP
);
4882 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4884 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4885 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4887 cp_binding_level
*b
= current_binding_level
;
4890 if (purpose_member (name
, b
->type_shadowed
))
4892 t
= REAL_IDENTIFIER_TYPE_VALUE (name
);
4895 if (b
->kind
== sk_cleanup
)
4902 timevar_stop (TV_NAME_LOOKUP
);
4906 /* [basic.lookup.koenig] */
4907 /* A nonzero return value in the functions below indicates an error. */
4913 VEC(tree
,gc
) *namespaces
;
4914 VEC(tree
,gc
) *classes
;
4916 struct pointer_set_t
*fn_set
;
4919 static bool arg_assoc (struct arg_lookup
*, tree
);
4920 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4921 static bool arg_assoc_args_vec (struct arg_lookup
*, VEC(tree
,gc
) *);
4922 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4923 static bool add_function (struct arg_lookup
*, tree
);
4924 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4925 static bool arg_assoc_class_only (struct arg_lookup
*, tree
);
4926 static bool arg_assoc_bases (struct arg_lookup
*, tree
);
4927 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4928 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4930 /* Add a function to the lookup structure.
4931 Returns true on error. */
4934 add_function (struct arg_lookup
*k
, tree fn
)
4936 if (!is_overloaded_fn (fn
))
4937 /* All names except those of (possibly overloaded) functions and
4938 function templates are ignored. */;
4939 else if (k
->fn_set
&& pointer_set_insert (k
->fn_set
, fn
))
4940 /* It's already in the list. */;
4941 else if (!k
->functions
)
4943 else if (fn
== k
->functions
)
4947 k
->functions
= build_overload (fn
, k
->functions
);
4948 if (TREE_CODE (k
->functions
) == OVERLOAD
)
4949 OVL_ARG_DEPENDENT (k
->functions
) = true;
4955 /* Returns true iff CURRENT has declared itself to be an associated
4956 namespace of SCOPE via a strong using-directive (or transitive chain
4957 thereof). Both are namespaces. */
4960 is_associated_namespace (tree current
, tree scope
)
4962 VEC(tree
,gc
) *seen
= make_tree_vector ();
4963 VEC(tree
,gc
) *todo
= make_tree_vector ();
4969 if (scope
== current
)
4974 VEC_safe_push (tree
, gc
, seen
, scope
);
4975 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4976 if (!vec_member (TREE_PURPOSE (t
), seen
))
4977 VEC_safe_push (tree
, gc
, todo
, TREE_PURPOSE (t
));
4978 if (!VEC_empty (tree
, todo
))
4980 scope
= VEC_last (tree
, todo
);
4981 VEC_pop (tree
, todo
);
4990 release_tree_vector (seen
);
4991 release_tree_vector (todo
);
4996 /* Add functions of a namespace to the lookup structure.
4997 Returns true on error. */
5000 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
5004 if (vec_member (scope
, k
->namespaces
))
5006 VEC_safe_push (tree
, gc
, k
->namespaces
, scope
);
5008 /* Check out our super-users. */
5009 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
5010 value
= TREE_CHAIN (value
))
5011 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5014 /* Also look down into inline namespaces. */
5015 for (value
= DECL_NAMESPACE_USING (scope
); value
;
5016 value
= TREE_CHAIN (value
))
5017 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
5018 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5021 value
= namespace_binding (k
->name
, scope
);
5025 for (; value
; value
= OVL_NEXT (value
))
5027 /* We don't want to find arbitrary hidden functions via argument
5028 dependent lookup. We only want to find friends of associated
5029 classes, which we'll do via arg_assoc_class. */
5030 if (hidden_name_p (OVL_CURRENT (value
)))
5033 if (add_function (k
, OVL_CURRENT (value
)))
5040 /* Adds everything associated with a template argument to the lookup
5041 structure. Returns true on error. */
5044 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
5046 /* [basic.lookup.koenig]
5048 If T is a template-id, its associated namespaces and classes are
5049 ... the namespaces and classes associated with the types of the
5050 template arguments provided for template type parameters
5051 (excluding template template parameters); the namespaces in which
5052 any template template arguments are defined; and the classes in
5053 which any member templates used as template template arguments
5054 are defined. [Note: non-type template arguments do not
5055 contribute to the set of associated namespaces. ] */
5057 /* Consider first template template arguments. */
5058 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
5059 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
5061 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
5063 tree ctx
= CP_DECL_CONTEXT (arg
);
5065 /* It's not a member template. */
5066 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
5067 return arg_assoc_namespace (k
, ctx
);
5068 /* Otherwise, it must be member template. */
5070 return arg_assoc_class_only (k
, ctx
);
5072 /* It's an argument pack; handle it recursively. */
5073 else if (ARGUMENT_PACK_P (arg
))
5075 tree args
= ARGUMENT_PACK_ARGS (arg
);
5076 int i
, len
= TREE_VEC_LENGTH (args
);
5077 for (i
= 0; i
< len
; ++i
)
5078 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
5083 /* It's not a template template argument, but it is a type template
5085 else if (TYPE_P (arg
))
5086 return arg_assoc_type (k
, arg
);
5087 /* It's a non-type template argument. */
5092 /* Adds the class and its friends to the lookup structure.
5093 Returns true on error. */
5096 arg_assoc_class_only (struct arg_lookup
*k
, tree type
)
5098 tree list
, friends
, context
;
5100 /* Backend-built structures, such as __builtin_va_list, aren't
5101 affected by all this. */
5102 if (!CLASS_TYPE_P (type
))
5105 context
= decl_namespace_context (type
);
5106 if (arg_assoc_namespace (k
, context
))
5109 complete_type (type
);
5111 /* Process friends. */
5112 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
5113 list
= TREE_CHAIN (list
))
5114 if (k
->name
== FRIEND_NAME (list
))
5115 for (friends
= FRIEND_DECLS (list
); friends
;
5116 friends
= TREE_CHAIN (friends
))
5118 tree fn
= TREE_VALUE (friends
);
5120 /* Only interested in global functions with potentially hidden
5121 (i.e. unqualified) declarations. */
5122 if (CP_DECL_CONTEXT (fn
) != context
)
5124 /* Template specializations are never found by name lookup.
5125 (Templates themselves can be found, but not template
5126 specializations.) */
5127 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
5129 if (add_function (k
, fn
))
5136 /* Adds the class and its bases to the lookup structure.
5137 Returns true on error. */
5140 arg_assoc_bases (struct arg_lookup
*k
, tree type
)
5142 if (arg_assoc_class_only (k
, type
))
5145 if (TYPE_BINFO (type
))
5147 /* Process baseclasses. */
5148 tree binfo
, base_binfo
;
5151 for (binfo
= TYPE_BINFO (type
), i
= 0;
5152 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5153 if (arg_assoc_bases (k
, BINFO_TYPE (base_binfo
)))
5160 /* Adds everything associated with a class argument type to the lookup
5161 structure. Returns true on error.
5163 If T is a class type (including unions), its associated classes are: the
5164 class itself; the class of which it is a member, if any; and its direct
5165 and indirect base classes. Its associated namespaces are the namespaces
5166 of which its associated classes are members. Furthermore, if T is a
5167 class template specialization, its associated namespaces and classes
5168 also include: the namespaces and classes associated with the types of
5169 the template arguments provided for template type parameters (excluding
5170 template template parameters); the namespaces of which any template
5171 template arguments are members; and the classes of which any member
5172 templates used as template template arguments are members. [ Note:
5173 non-type template arguments do not contribute to the set of associated
5174 namespaces. --end note] */
5177 arg_assoc_class (struct arg_lookup
*k
, tree type
)
5182 /* Backend build structures, such as __builtin_va_list, aren't
5183 affected by all this. */
5184 if (!CLASS_TYPE_P (type
))
5187 if (vec_member (type
, k
->classes
))
5189 VEC_safe_push (tree
, gc
, k
->classes
, type
);
5191 if (TYPE_CLASS_SCOPE_P (type
)
5192 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5195 if (arg_assoc_bases (k
, type
))
5198 /* Process template arguments. */
5199 if (CLASSTYPE_TEMPLATE_INFO (type
)
5200 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
5202 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
5203 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
5204 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
)))
5211 /* Adds everything associated with a given type.
5212 Returns 1 on error. */
5215 arg_assoc_type (struct arg_lookup
*k
, tree type
)
5217 /* As we do not get the type of non-type dependent expressions
5218 right, we can end up with such things without a type. */
5222 if (TYPE_PTRMEM_P (type
))
5224 /* Pointer to member: associate class type and value type. */
5225 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
5227 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
5229 else switch (TREE_CODE (type
))
5239 case FIXED_POINT_TYPE
:
5244 if (TYPE_PTRMEMFUNC_P (type
))
5245 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
5247 return arg_assoc_class (k
, type
);
5249 case REFERENCE_TYPE
:
5251 return arg_assoc_type (k
, TREE_TYPE (type
));
5253 if (TYPE_CLASS_SCOPE_P (type
)
5254 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5256 return arg_assoc_namespace (k
, decl_namespace_context (type
));
5258 /* The basetype is referenced in the first arg type, so just
5261 /* Associate the parameter types. */
5262 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
5264 /* Associate the return type. */
5265 return arg_assoc_type (k
, TREE_TYPE (type
));
5266 case TEMPLATE_TYPE_PARM
:
5267 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5272 gcc_assert (type
== unknown_type_node
5273 || type
== init_list_type_node
);
5275 case TYPE_PACK_EXPANSION
:
5276 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
5284 /* Adds everything associated with arguments. Returns true on error. */
5287 arg_assoc_args (struct arg_lookup
*k
, tree args
)
5289 for (; args
; args
= TREE_CHAIN (args
))
5290 if (arg_assoc (k
, TREE_VALUE (args
)))
5295 /* Adds everything associated with an argument vector. Returns true
5299 arg_assoc_args_vec (struct arg_lookup
*k
, VEC(tree
,gc
) *args
)
5304 FOR_EACH_VEC_ELT (tree
, args
, ix
, arg
)
5305 if (arg_assoc (k
, arg
))
5310 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5313 arg_assoc (struct arg_lookup
*k
, tree n
)
5315 if (n
== error_mark_node
)
5319 return arg_assoc_type (k
, n
);
5321 if (! type_unknown_p (n
))
5322 return arg_assoc_type (k
, TREE_TYPE (n
));
5324 if (TREE_CODE (n
) == ADDR_EXPR
)
5325 n
= TREE_OPERAND (n
, 0);
5326 if (TREE_CODE (n
) == COMPONENT_REF
)
5327 n
= TREE_OPERAND (n
, 1);
5328 if (TREE_CODE (n
) == OFFSET_REF
)
5329 n
= TREE_OPERAND (n
, 1);
5330 while (TREE_CODE (n
) == TREE_LIST
)
5332 if (TREE_CODE (n
) == BASELINK
)
5333 n
= BASELINK_FUNCTIONS (n
);
5335 if (TREE_CODE (n
) == FUNCTION_DECL
)
5336 return arg_assoc_type (k
, TREE_TYPE (n
));
5337 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
5339 /* The working paper doesn't currently say how to handle template-id
5340 arguments. The sensible thing would seem to be to handle the list
5341 of template candidates like a normal overload set, and handle the
5342 template arguments like we do for class template
5344 tree templ
= TREE_OPERAND (n
, 0);
5345 tree args
= TREE_OPERAND (n
, 1);
5348 /* First the templates. */
5349 if (arg_assoc (k
, templ
))
5352 /* Now the arguments. */
5354 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
5355 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
5358 else if (TREE_CODE (n
) == OVERLOAD
)
5360 for (; n
; n
= OVL_NEXT (n
))
5361 if (arg_assoc_type (k
, TREE_TYPE (OVL_CURRENT (n
))))
5368 /* Performs Koenig lookup depending on arguments, where fns
5369 are the functions found in normal lookup. */
5372 lookup_arg_dependent_1 (tree name
, tree fns
, VEC(tree
,gc
) *args
,
5375 struct arg_lookup k
;
5377 /* Remove any hidden friend functions from the list of functions
5378 found so far. They will be added back by arg_assoc_class as
5380 fns
= remove_hidden_names (fns
);
5385 k
.classes
= make_tree_vector ();
5387 /* We previously performed an optimization here by setting
5388 NAMESPACES to the current namespace when it was safe. However, DR
5389 164 says that namespaces that were already searched in the first
5390 stage of template processing are searched again (potentially
5391 picking up later definitions) in the second stage. */
5392 k
.namespaces
= make_tree_vector ();
5394 /* We used to allow duplicates and let joust discard them, but
5395 since the above change for DR 164 we end up with duplicates of
5396 all the functions found by unqualified lookup. So keep track
5397 of which ones we've seen. */
5401 /* We shouldn't be here if lookup found something other than
5402 namespace-scope functions. */
5403 gcc_assert (DECL_NAMESPACE_SCOPE_P (OVL_CURRENT (fns
)));
5404 k
.fn_set
= pointer_set_create ();
5405 for (ovl
= fns
; ovl
; ovl
= OVL_NEXT (ovl
))
5406 pointer_set_insert (k
.fn_set
, OVL_CURRENT (ovl
));
5412 arg_assoc_namespace (&k
, std_node
);
5413 arg_assoc_args_vec (&k
, args
);
5418 && TREE_CODE (fns
) != VAR_DECL
5419 && !is_overloaded_fn (fns
))
5421 error ("argument dependent lookup finds %q+D", fns
);
5422 error (" in call to %qD", name
);
5423 fns
= error_mark_node
;
5426 release_tree_vector (k
.classes
);
5427 release_tree_vector (k
.namespaces
);
5429 pointer_set_destroy (k
.fn_set
);
5434 /* Wrapper for lookup_arg_dependent_1. */
5437 lookup_arg_dependent (tree name
, tree fns
, VEC(tree
,gc
) *args
,
5442 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5443 ret
= lookup_arg_dependent_1 (name
, fns
, args
, include_std
);
5444 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5449 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5450 changed (i.e. there was already a directive), or the fresh
5451 TREE_LIST otherwise. */
5454 push_using_directive_1 (tree used
)
5456 tree ud
= current_binding_level
->using_directives
;
5457 tree iter
, ancestor
;
5459 /* Check if we already have this. */
5460 if (purpose_member (used
, ud
) != NULL_TREE
)
5463 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
5464 ud
= current_binding_level
->using_directives
;
5465 ud
= tree_cons (used
, ancestor
, ud
);
5466 current_binding_level
->using_directives
= ud
;
5468 /* Recursively add all namespaces used. */
5469 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
5470 push_using_directive (TREE_PURPOSE (iter
));
5475 /* Wrapper for push_using_directive_1. */
5478 push_using_directive (tree used
)
5481 timevar_start (TV_NAME_LOOKUP
);
5482 ret
= push_using_directive_1 (used
);
5483 timevar_stop (TV_NAME_LOOKUP
);
5487 /* The type TYPE is being declared. If it is a class template, or a
5488 specialization of a class template, do any processing required and
5489 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5490 being declared a friend. B is the binding level at which this TYPE
5493 Returns the TYPE_DECL for TYPE, which may have been altered by this
5497 maybe_process_template_type_declaration (tree type
, int is_friend
,
5498 cp_binding_level
*b
)
5500 tree decl
= TYPE_NAME (type
);
5502 if (processing_template_parmlist
)
5503 /* You can't declare a new template type in a template parameter
5504 list. But, you can declare a non-template type:
5506 template <class A*> struct S;
5508 is a forward-declaration of `A'. */
5510 else if (b
->kind
== sk_namespace
5511 && current_binding_level
->kind
!= sk_namespace
)
5512 /* If this new type is being injected into a containing scope,
5513 then it's not a template type. */
5517 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5518 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5520 if (processing_template_decl
)
5522 /* This may change after the call to
5523 push_template_decl_real, but we want the original value. */
5524 tree name
= DECL_NAME (decl
);
5526 decl
= push_template_decl_real (decl
, is_friend
);
5527 if (decl
== error_mark_node
)
5528 return error_mark_node
;
5530 /* If the current binding level is the binding level for the
5531 template parameters (see the comment in
5532 begin_template_parm_list) and the enclosing level is a class
5533 scope, and we're not looking at a friend, push the
5534 declaration of the member class into the class scope. In the
5535 friend case, push_template_decl will already have put the
5536 friend into global scope, if appropriate. */
5537 if (TREE_CODE (type
) != ENUMERAL_TYPE
5538 && !is_friend
&& b
->kind
== sk_template_parms
5539 && b
->level_chain
->kind
== sk_class
)
5541 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5543 if (!COMPLETE_TYPE_P (current_class_type
))
5545 maybe_add_class_template_decl_list (current_class_type
,
5546 type
, /*friend_p=*/0);
5547 /* Put this UTD in the table of UTDs for the class. */
5548 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5549 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5550 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5552 binding_table_insert
5553 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5562 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5563 that the NAME is a class template, the tag is processed but not pushed.
5565 The pushed scope depend on the SCOPE parameter:
5566 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5568 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5569 non-template-parameter scope. This case is needed for forward
5571 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5572 TS_GLOBAL case except that names within template-parameter scopes
5573 are not pushed at all.
5575 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5578 pushtag_1 (tree name
, tree type
, tag_scope scope
)
5580 cp_binding_level
*b
;
5583 b
= current_binding_level
;
5584 while (/* Cleanup scopes are not scopes from the point of view of
5586 b
->kind
== sk_cleanup
5587 /* Neither are function parameter scopes. */
5588 || b
->kind
== sk_function_parms
5589 /* Neither are the scopes used to hold template parameters
5590 for an explicit specialization. For an ordinary template
5591 declaration, these scopes are not scopes from the point of
5592 view of the language. */
5593 || (b
->kind
== sk_template_parms
5594 && (b
->explicit_spec_p
|| scope
== ts_global
))
5595 || (b
->kind
== sk_class
5596 && (scope
!= ts_current
5597 /* We may be defining a new type in the initializer
5598 of a static member variable. We allow this when
5599 not pedantic, and it is particularly useful for
5600 type punning via an anonymous union. */
5601 || COMPLETE_TYPE_P (b
->this_entity
))))
5604 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5606 /* Do C++ gratuitous typedefing. */
5607 if (identifier_type_value_1 (name
) != type
)
5611 tree context
= TYPE_CONTEXT (type
);
5615 tree cs
= current_scope ();
5617 if (scope
== ts_current
5618 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
5620 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5621 /* When declaring a friend class of a local class, we want
5622 to inject the newly named class into the scope
5623 containing the local class, not the namespace
5625 context
= decl_function_context (get_type_decl (cs
));
5628 context
= current_namespace
;
5630 if (b
->kind
== sk_class
5631 || (b
->kind
== sk_template_parms
5632 && b
->level_chain
->kind
== sk_class
))
5635 if (current_lang_name
== lang_name_java
)
5636 TYPE_FOR_JAVA (type
) = 1;
5638 tdef
= create_implicit_typedef (name
, type
);
5639 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5640 if (scope
== ts_within_enclosing_non_class
)
5642 /* This is a friend. Make this TYPE_DECL node hidden from
5643 ordinary name lookup. Its corresponding TEMPLATE_DECL
5644 will be marked in push_template_decl_real. */
5645 retrofit_lang_decl (tdef
);
5646 DECL_ANTICIPATED (tdef
) = 1;
5647 DECL_FRIEND_P (tdef
) = 1;
5650 decl
= maybe_process_template_type_declaration
5651 (type
, scope
== ts_within_enclosing_non_class
, b
);
5652 if (decl
== error_mark_node
)
5655 if (b
->kind
== sk_class
)
5657 if (!TYPE_BEING_DEFINED (current_class_type
))
5658 return error_mark_node
;
5660 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5661 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5662 class. But if it's a member template class, we want
5663 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5665 finish_member_declaration (decl
);
5667 pushdecl_class_level (decl
);
5669 else if (b
->kind
!= sk_template_parms
)
5671 decl
= pushdecl_with_scope_1 (decl
, b
, /*is_friend=*/false);
5672 if (decl
== error_mark_node
)
5677 set_identifier_type_value_with_scope (name
, tdef
, b
);
5679 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5681 /* If this is a local class, keep track of it. We need this
5682 information for name-mangling, and so that it is possible to
5683 find all function definitions in a translation unit in a
5684 convenient way. (It's otherwise tricky to find a member
5685 function definition it's only pointed to from within a local
5687 if (TYPE_CONTEXT (type
)
5688 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
5689 VEC_safe_push (tree
, gc
, local_classes
, type
);
5691 if (b
->kind
== sk_class
5692 && !COMPLETE_TYPE_P (current_class_type
))
5694 maybe_add_class_template_decl_list (current_class_type
,
5695 type
, /*friend_p=*/0);
5697 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5698 CLASSTYPE_NESTED_UTDS (current_class_type
)
5699 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5701 binding_table_insert
5702 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5705 decl
= TYPE_NAME (type
);
5706 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
5708 /* Set type visibility now if this is a forward declaration. */
5709 TREE_PUBLIC (decl
) = 1;
5710 determine_visibility (decl
);
5715 /* Wrapper for pushtag_1. */
5718 pushtag (tree name
, tree type
, tag_scope scope
)
5721 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5722 ret
= pushtag_1 (name
, type
, scope
);
5723 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5727 /* Subroutines for reverting temporarily to top-level for instantiation
5728 of templates and such. We actually need to clear out the class- and
5729 local-value slots of all identifiers, so that only the global values
5730 are at all visible. Simply setting current_binding_level to the global
5731 scope isn't enough, because more binding levels may be pushed. */
5732 struct saved_scope
*scope_chain
;
5734 /* If ID has not already been marked, add an appropriate binding to
5738 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5740 cxx_saved_binding
*saved
;
5742 if (!id
|| !IDENTIFIER_BINDING (id
))
5745 if (IDENTIFIER_MARKED (id
))
5748 IDENTIFIER_MARKED (id
) = 1;
5750 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
5751 saved
->identifier
= id
;
5752 saved
->binding
= IDENTIFIER_BINDING (id
);
5753 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
5754 IDENTIFIER_BINDING (id
) = NULL
;
5758 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5762 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5763 for (t
= names
; t
; t
= TREE_CHAIN (t
))
5767 if (TREE_CODE (t
) == TREE_LIST
)
5768 id
= TREE_PURPOSE (t
);
5772 store_binding (id
, old_bindings
);
5774 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5777 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5778 objects, rather than a TREE_LIST. */
5781 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
5782 VEC(cxx_saved_binding
,gc
) **old_bindings
)
5785 cp_class_binding
*cb
;
5787 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5788 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
5789 store_binding (cb
->identifier
, old_bindings
);
5790 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5794 push_to_top_level (void)
5796 struct saved_scope
*s
;
5797 cp_binding_level
*b
;
5798 cxx_saved_binding
*sb
;
5802 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5803 s
= ggc_alloc_cleared_saved_scope ();
5805 b
= scope_chain
? current_binding_level
: 0;
5807 /* If we're in the middle of some function, save our state. */
5811 push_function_context ();
5816 if (scope_chain
&& previous_class_level
)
5817 store_class_bindings (previous_class_level
->class_shadowed
,
5820 /* Have to include the global scope, because class-scope decls
5821 aren't listed anywhere useful. */
5822 for (; b
; b
= b
->level_chain
)
5826 /* Template IDs are inserted into the global level. If they were
5827 inserted into namespace level, finish_file wouldn't find them
5828 when doing pending instantiations. Therefore, don't stop at
5829 namespace level, but continue until :: . */
5830 if (global_scope_p (b
))
5833 store_bindings (b
->names
, &s
->old_bindings
);
5834 /* We also need to check class_shadowed to save class-level type
5835 bindings, since pushclass doesn't fill in b->names. */
5836 if (b
->kind
== sk_class
)
5837 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
5839 /* Unwind type-value slots back to top level. */
5840 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
5841 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
5844 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, sb
)
5845 IDENTIFIER_MARKED (sb
->identifier
) = 0;
5847 s
->prev
= scope_chain
;
5849 s
->need_pop_function_context
= need_pop
;
5850 s
->function_decl
= current_function_decl
;
5851 s
->unevaluated_operand
= cp_unevaluated_operand
;
5852 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
5855 current_function_decl
= NULL_TREE
;
5856 current_lang_base
= VEC_alloc (tree
, gc
, 10);
5857 current_lang_name
= lang_name_cplusplus
;
5858 current_namespace
= global_namespace
;
5859 push_class_stack ();
5860 cp_unevaluated_operand
= 0;
5861 c_inhibit_evaluation_warnings
= 0;
5862 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5866 pop_from_top_level_1 (void)
5868 struct saved_scope
*s
= scope_chain
;
5869 cxx_saved_binding
*saved
;
5872 /* Clear out class-level bindings cache. */
5873 if (previous_class_level
)
5874 invalidate_class_lookup_cache ();
5877 current_lang_base
= 0;
5879 scope_chain
= s
->prev
;
5880 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, saved
)
5882 tree id
= saved
->identifier
;
5884 IDENTIFIER_BINDING (id
) = saved
->binding
;
5885 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
5888 /* If we were in the middle of compiling a function, restore our
5890 if (s
->need_pop_function_context
)
5891 pop_function_context ();
5892 current_function_decl
= s
->function_decl
;
5893 cp_unevaluated_operand
= s
->unevaluated_operand
;
5894 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
5897 /* Wrapper for pop_from_top_level_1. */
5900 pop_from_top_level (void)
5902 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5903 pop_from_top_level_1 ();
5904 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5908 /* Pop off extraneous binding levels left over due to syntax errors.
5910 We don't pop past namespaces, as they might be valid. */
5913 pop_everything (void)
5915 if (ENABLE_SCOPE_CHECKING
)
5916 verbatim ("XXX entering pop_everything ()\n");
5917 while (!toplevel_bindings_p ())
5919 if (current_binding_level
->kind
== sk_class
)
5920 pop_nested_class ();
5924 if (ENABLE_SCOPE_CHECKING
)
5925 verbatim ("XXX leaving pop_everything ()\n");
5928 /* Emit debugging information for using declarations and directives.
5929 If input tree is overloaded fn then emit debug info for all
5933 cp_emit_debug_info_for_using (tree t
, tree context
)
5935 /* Don't try to emit any debug information if we have errors. */
5939 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5940 of a builtin function. */
5941 if (TREE_CODE (t
) == FUNCTION_DECL
5942 && DECL_EXTERNAL (t
)
5943 && DECL_BUILT_IN (t
))
5946 /* Do not supply context to imported_module_or_decl, if
5947 it is a global namespace. */
5948 if (context
== global_namespace
)
5949 context
= NULL_TREE
;
5952 t
= BASELINK_FUNCTIONS (t
);
5954 /* FIXME: Handle TEMPLATE_DECLs. */
5955 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
5956 if (TREE_CODE (t
) != TEMPLATE_DECL
)
5958 if (building_stmt_list_p ())
5959 add_stmt (build_stmt (input_location
, USING_STMT
, t
));
5961 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
5965 #include "gt-cp-name-lookup.h"