1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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"
37 /* The bindings for a particular name in a particular scope. */
39 struct scope_binding
{
43 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
45 static cxx_scope
*innermost_nonclass_level (void);
46 static cxx_binding
*binding_for_name (cxx_scope
*, tree
);
47 static tree
push_overloaded_decl (tree
, int, bool);
48 static bool lookup_using_namespace (tree
, struct scope_binding
*, tree
,
50 static bool qualified_lookup_using_namespace (tree
, tree
,
51 struct scope_binding
*, int);
52 static tree
lookup_type_current_level (tree
);
53 static tree
push_using_directive (tree
);
54 static cxx_binding
* lookup_extern_c_fun_binding_in_all_ns (tree
);
56 /* The :: namespace. */
58 tree global_namespace
;
60 /* The name of the anonymous namespace, throughout this translation
62 static GTY(()) tree anonymous_namespace_name
;
64 /* Initialize anonymous_namespace_name if necessary, and return it. */
67 get_anonymous_namespace_name (void)
69 if (!anonymous_namespace_name
)
71 /* The anonymous namespace has to have a unique name
72 if typeinfo objects are being compared by name. */
73 if (! flag_weak
|| ! SUPPORTS_ONE_ONLY
)
74 anonymous_namespace_name
= get_file_function_name ("N");
76 /* The demangler expects anonymous namespaces to be called
77 something starting with '_GLOBAL__N_'. */
78 anonymous_namespace_name
= get_identifier ("_GLOBAL__N_1");
80 return anonymous_namespace_name
;
83 /* Compute the chain index of a binding_entry given the HASH value of its
84 name and the total COUNT of chains. COUNT is assumed to be a power
87 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
89 /* A free list of "binding_entry"s awaiting for re-use. */
91 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
93 /* Create a binding_entry object for (NAME, TYPE). */
95 static inline binding_entry
96 binding_entry_make (tree name
, tree type
)
100 if (free_binding_entry
)
102 entry
= free_binding_entry
;
103 free_binding_entry
= entry
->chain
;
106 entry
= ggc_alloc_binding_entry_s ();
115 /* Put ENTRY back on the free list. */
118 binding_entry_free (binding_entry entry
)
122 entry
->chain
= free_binding_entry
;
123 free_binding_entry
= entry
;
127 /* The datatype used to implement the mapping from names to types at
129 struct GTY(()) binding_table_s
{
130 /* Array of chains of "binding_entry"s */
131 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
133 /* The number of chains in this table. This is the length of the
134 member "chain" considered as an array. */
137 /* Number of "binding_entry"s in this table. */
141 /* Construct TABLE with an initial CHAIN_COUNT. */
144 binding_table_construct (binding_table table
, size_t chain_count
)
146 table
->chain_count
= chain_count
;
147 table
->entry_count
= 0;
148 table
->chain
= ggc_alloc_cleared_vec_binding_entry (table
->chain_count
);
151 /* Make TABLE's entries ready for reuse. */
154 binding_table_free (binding_table table
)
162 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
164 binding_entry temp
= table
->chain
[i
];
167 binding_entry entry
= temp
;
169 binding_entry_free (entry
);
171 table
->chain
[i
] = NULL
;
173 table
->entry_count
= 0;
177 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
179 static inline binding_table
180 binding_table_new (size_t chain_count
)
182 binding_table table
= ggc_alloc_binding_table_s ();
184 binding_table_construct (table
, chain_count
);
188 /* Expand TABLE to twice its current chain_count. */
191 binding_table_expand (binding_table table
)
193 const size_t old_chain_count
= table
->chain_count
;
194 const size_t old_entry_count
= table
->entry_count
;
195 const size_t new_chain_count
= 2 * old_chain_count
;
196 binding_entry
*old_chains
= table
->chain
;
199 binding_table_construct (table
, new_chain_count
);
200 for (i
= 0; i
< old_chain_count
; ++i
)
202 binding_entry entry
= old_chains
[i
];
203 for (; entry
!= NULL
; entry
= old_chains
[i
])
205 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
206 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
208 old_chains
[i
] = entry
->chain
;
209 entry
->chain
= table
->chain
[j
];
210 table
->chain
[j
] = entry
;
213 table
->entry_count
= old_entry_count
;
216 /* Insert a binding for NAME to TYPE into TABLE. */
219 binding_table_insert (binding_table table
, tree name
, tree type
)
221 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
222 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
223 binding_entry entry
= binding_entry_make (name
, type
);
225 entry
->chain
= table
->chain
[i
];
226 table
->chain
[i
] = entry
;
227 ++table
->entry_count
;
229 if (3 * table
->chain_count
< 5 * table
->entry_count
)
230 binding_table_expand (table
);
233 /* Return the binding_entry, if any, that maps NAME. */
236 binding_table_find (binding_table table
, tree name
)
238 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
239 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
241 while (entry
!= NULL
&& entry
->name
!= name
)
242 entry
= entry
->chain
;
247 /* Apply PROC -- with DATA -- to all entries in TABLE. */
250 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
252 const size_t chain_count
= table
->chain_count
;
255 for (i
= 0; i
< chain_count
; ++i
)
257 binding_entry entry
= table
->chain
[i
];
258 for (; entry
!= NULL
; entry
= entry
->chain
)
263 #ifndef ENABLE_SCOPE_CHECKING
264 # define ENABLE_SCOPE_CHECKING 0
266 # define ENABLE_SCOPE_CHECKING 1
269 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
271 static GTY((deletable
)) cxx_binding
*free_bindings
;
273 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
277 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
279 binding
->value
= value
;
280 binding
->type
= type
;
281 binding
->previous
= NULL
;
284 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
287 cxx_binding_make (tree value
, tree type
)
289 cxx_binding
*binding
;
292 binding
= free_bindings
;
293 free_bindings
= binding
->previous
;
296 binding
= ggc_alloc_cxx_binding ();
298 cxx_binding_init (binding
, value
, type
);
303 /* Put BINDING back on the free list. */
306 cxx_binding_free (cxx_binding
*binding
)
308 binding
->scope
= NULL
;
309 binding
->previous
= free_bindings
;
310 free_bindings
= binding
;
313 /* Create a new binding for NAME (with the indicated VALUE and TYPE
314 bindings) in the class scope indicated by SCOPE. */
317 new_class_binding (tree name
, tree value
, tree type
, cxx_scope
*scope
)
319 cp_class_binding
*cb
;
320 cxx_binding
*binding
;
322 if (VEC_length (cp_class_binding
, scope
->class_shadowed
))
324 cp_class_binding
*old_base
;
325 old_base
= VEC_index (cp_class_binding
, scope
->class_shadowed
, 0);
326 if (VEC_reserve (cp_class_binding
, gc
, scope
->class_shadowed
, 1))
328 /* Fixup the current bindings, as they might have moved. */
331 FOR_EACH_VEC_ELT (cp_class_binding
, scope
->class_shadowed
, i
, cb
)
334 b
= &IDENTIFIER_BINDING (cb
->identifier
);
335 while (*b
!= &old_base
[i
].base
)
336 b
= &((*b
)->previous
);
340 cb
= VEC_quick_push (cp_class_binding
, scope
->class_shadowed
, NULL
);
343 cb
= VEC_safe_push (cp_class_binding
, gc
, scope
->class_shadowed
, NULL
);
345 cb
->identifier
= name
;
347 binding
->scope
= scope
;
348 cxx_binding_init (binding
, value
, type
);
352 /* Make DECL the innermost binding for ID. The LEVEL is the binding
353 level at which this declaration is being bound. */
356 push_binding (tree id
, tree decl
, cxx_scope
* level
)
358 cxx_binding
*binding
;
360 if (level
!= class_binding_level
)
362 binding
= cxx_binding_make (decl
, NULL_TREE
);
363 binding
->scope
= level
;
366 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
368 /* Now, fill in the binding information. */
369 binding
->previous
= IDENTIFIER_BINDING (id
);
370 INHERITED_VALUE_BINDING_P (binding
) = 0;
371 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
373 /* And put it on the front of the list of bindings for ID. */
374 IDENTIFIER_BINDING (id
) = binding
;
377 /* Remove the binding for DECL which should be the innermost binding
381 pop_binding (tree id
, tree decl
)
383 cxx_binding
*binding
;
386 /* It's easiest to write the loops that call this function without
387 checking whether or not the entities involved have names. We
388 get here for such an entity. */
391 /* Get the innermost binding for ID. */
392 binding
= IDENTIFIER_BINDING (id
);
394 /* The name should be bound. */
395 gcc_assert (binding
!= NULL
);
397 /* The DECL will be either the ordinary binding or the type
398 binding for this identifier. Remove that binding. */
399 if (binding
->value
== decl
)
400 binding
->value
= NULL_TREE
;
403 gcc_assert (binding
->type
== decl
);
404 binding
->type
= NULL_TREE
;
407 if (!binding
->value
&& !binding
->type
)
409 /* We're completely done with the innermost binding for this
410 identifier. Unhook it from the list of bindings. */
411 IDENTIFIER_BINDING (id
) = binding
->previous
;
413 /* Add it to the free list. */
414 cxx_binding_free (binding
);
418 /* BINDING records an existing declaration for a name in the current scope.
419 But, DECL is another declaration for that same identifier in the
420 same scope. This is the `struct stat' hack whereby a non-typedef
421 class name or enum-name can be bound at the same level as some other
425 A class name (9.1) or enumeration name (7.2) can be hidden by the
426 name of an object, function, or enumerator declared in the same scope.
427 If a class or enumeration name and an object, function, or enumerator
428 are declared in the same scope (in any order) with the same name, the
429 class or enumeration name is hidden wherever the object, function, or
430 enumerator name is visible.
432 It's the responsibility of the caller to check that
433 inserting this name is valid here. Returns nonzero if the new binding
437 supplement_binding (cxx_binding
*binding
, tree decl
)
439 tree bval
= binding
->value
;
442 timevar_push (TV_NAME_LOOKUP
);
443 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
444 /* The new name is the type name. */
445 binding
->type
= decl
;
446 else if (/* BVAL is null when push_class_level_binding moves an
447 inherited type-binding out of the way to make room for a
448 new value binding. */
450 /* BVAL is error_mark_node when DECL's name has been used
451 in a non-class scope prior declaration. In that case,
452 we should have already issued a diagnostic; for graceful
453 error recovery purpose, pretend this was the intended
454 declaration for that name. */
455 || bval
== error_mark_node
456 /* If BVAL is anticipated but has not yet been declared,
457 pretend it is not there at all. */
458 || (TREE_CODE (bval
) == FUNCTION_DECL
459 && DECL_ANTICIPATED (bval
)
460 && !DECL_HIDDEN_FRIEND_P (bval
)))
461 binding
->value
= decl
;
462 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
464 /* The old binding was a type name. It was placed in
465 VALUE field because it was thought, at the point it was
466 declared, to be the only entity with such a name. Move the
467 type name into the type slot; it is now hidden by the new
469 binding
->type
= bval
;
470 binding
->value
= decl
;
471 binding
->value_is_inherited
= false;
473 else if (TREE_CODE (bval
) == TYPE_DECL
474 && TREE_CODE (decl
) == TYPE_DECL
475 && DECL_NAME (decl
) == DECL_NAME (bval
)
476 && binding
->scope
->kind
!= sk_class
477 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
478 /* If either type involves template parameters, we must
479 wait until instantiation. */
480 || uses_template_parms (TREE_TYPE (decl
))
481 || uses_template_parms (TREE_TYPE (bval
))))
482 /* We have two typedef-names, both naming the same type to have
483 the same name. In general, this is OK because of:
487 In a given scope, a typedef specifier can be used to redefine
488 the name of any type declared in that scope to refer to the
489 type to which it already refers.
491 However, in class scopes, this rule does not apply due to the
492 stricter language in [class.mem] prohibiting redeclarations of
495 /* There can be two block-scope declarations of the same variable,
496 so long as they are `extern' declarations. However, there cannot
497 be two declarations of the same static data member:
501 A member shall not be declared twice in the
502 member-specification. */
503 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
504 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
505 && !DECL_CLASS_SCOPE_P (decl
))
507 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
510 else if (TREE_CODE (decl
) == NAMESPACE_DECL
511 && TREE_CODE (bval
) == NAMESPACE_DECL
512 && DECL_NAMESPACE_ALIAS (decl
)
513 && DECL_NAMESPACE_ALIAS (bval
)
514 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
517 In a declarative region, a namespace-alias-definition can be
518 used to redefine a namespace-alias declared in that declarative
519 region to refer only to the namespace to which it already
524 error ("declaration of %q#D", decl
);
525 error ("conflicts with previous declaration %q+#D", bval
);
529 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
532 /* Add DECL to the list of things declared in B. */
535 add_decl_to_level (tree decl
, cxx_scope
*b
)
537 /* We used to record virtual tables as if they were ordinary
538 variables, but no longer do so. */
539 gcc_assert (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
)));
541 if (TREE_CODE (decl
) == NAMESPACE_DECL
542 && !DECL_NAMESPACE_ALIAS (decl
))
544 DECL_CHAIN (decl
) = b
->namespaces
;
545 b
->namespaces
= decl
;
549 /* We build up the list in reverse order, and reverse it later if
551 TREE_CHAIN (decl
) = b
->names
;
555 /* If appropriate, add decl to separate list of statics. We
556 include extern variables because they might turn out to be
557 static later. It's OK for this list to contain a few false
559 if (b
->kind
== sk_namespace
)
560 if ((TREE_CODE (decl
) == VAR_DECL
561 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
562 || (TREE_CODE (decl
) == FUNCTION_DECL
563 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
564 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
568 /* Record a decl-node X as belonging to the current lexical scope.
569 Check for errors (such as an incompatible declaration for the same
570 name already seen in the same scope). IS_FRIEND is true if X is
571 declared as a friend.
573 Returns either X or an old decl for the same name.
574 If an old decl is returned, it may have been smashed
575 to agree with what X says. */
578 pushdecl_maybe_friend (tree x
, bool is_friend
)
582 int need_new_binding
;
584 timevar_push (TV_NAME_LOOKUP
);
586 if (x
== error_mark_node
)
587 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
589 need_new_binding
= 1;
591 if (DECL_TEMPLATE_PARM_P (x
))
592 /* Template parameters have no context; they are not X::T even
593 when declared within a class or namespace. */
597 if (current_function_decl
&& x
!= current_function_decl
598 /* A local declaration for a function doesn't constitute
600 && TREE_CODE (x
) != FUNCTION_DECL
601 /* A local declaration for an `extern' variable is in the
602 scope of the current namespace, not the current
604 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
605 /* When parsing the parameter list of a function declarator,
606 don't set DECL_CONTEXT to an enclosing function. When we
607 push the PARM_DECLs in order to process the function body,
608 current_binding_level->this_entity will be set. */
609 && !(TREE_CODE (x
) == PARM_DECL
610 && current_binding_level
->kind
== sk_function_parms
611 && current_binding_level
->this_entity
== NULL
)
612 && !DECL_CONTEXT (x
))
613 DECL_CONTEXT (x
) = current_function_decl
;
615 /* If this is the declaration for a namespace-scope function,
616 but the declaration itself is in a local scope, mark the
618 if (TREE_CODE (x
) == FUNCTION_DECL
619 && DECL_NAMESPACE_SCOPE_P (x
)
620 && current_function_decl
621 && x
!= current_function_decl
)
622 DECL_LOCAL_FUNCTION_P (x
) = 1;
625 name
= DECL_NAME (x
);
628 int different_binding_level
= 0;
630 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
631 name
= TREE_OPERAND (name
, 0);
633 /* In case this decl was explicitly namespace-qualified, look it
634 up in its namespace context. */
635 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
636 t
= namespace_binding (name
, DECL_CONTEXT (x
));
638 t
= lookup_name_innermost_nonclass_level (name
);
640 /* [basic.link] If there is a visible declaration of an entity
641 with linkage having the same name and type, ignoring entities
642 declared outside the innermost enclosing namespace scope, the
643 block scope declaration declares that same entity and
644 receives the linkage of the previous declaration. */
645 if (! t
&& current_function_decl
&& x
!= current_function_decl
646 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
647 && DECL_EXTERNAL (x
))
649 /* Look in block scope. */
650 t
= innermost_non_namespace_value (name
);
651 /* Or in the innermost namespace. */
653 t
= namespace_binding (name
, DECL_CONTEXT (x
));
654 /* Does it have linkage? Note that if this isn't a DECL, it's an
655 OVERLOAD, which is OK. */
656 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
659 different_binding_level
= 1;
662 /* If we are declaring a function, and the result of name-lookup
663 was an OVERLOAD, look for an overloaded instance that is
664 actually the same as the function we are declaring. (If
665 there is one, we have to merge our declaration with the
666 previous declaration.) */
667 if (t
&& TREE_CODE (t
) == OVERLOAD
)
671 if (TREE_CODE (x
) == FUNCTION_DECL
)
672 for (match
= t
; match
; match
= OVL_NEXT (match
))
674 if (decls_match (OVL_CURRENT (match
), x
))
678 /* Just choose one. */
682 t
= OVL_CURRENT (match
);
687 if (t
&& t
!= error_mark_node
)
689 if (different_binding_level
)
691 if (decls_match (x
, t
))
692 /* The standard only says that the local extern
693 inherits linkage from the previous decl; in
694 particular, default args are not shared. Add
695 the decl into a hash table to make sure only
696 the previous decl in this case is seen by the
699 struct cxx_int_tree_map
*h
;
702 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
704 if (cp_function_chain
->extern_decl_map
== NULL
)
705 cp_function_chain
->extern_decl_map
706 = htab_create_ggc (20, cxx_int_tree_map_hash
,
707 cxx_int_tree_map_eq
, NULL
);
709 h
= ggc_alloc_cxx_int_tree_map ();
710 h
->uid
= DECL_UID (x
);
712 loc
= htab_find_slot_with_hash
713 (cp_function_chain
->extern_decl_map
, h
,
715 *(struct cxx_int_tree_map
**) loc
= h
;
718 else if (TREE_CODE (t
) == PARM_DECL
)
720 /* Check for duplicate params. */
721 tree d
= duplicate_decls (x
, t
, is_friend
);
723 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, d
);
725 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
726 || DECL_FUNCTION_TEMPLATE_P (x
))
727 && is_overloaded_fn (t
))
728 /* Don't do anything just yet. */;
729 else if (t
== wchar_decl_node
)
731 if (! DECL_IN_SYSTEM_HEADER (x
))
732 pedwarn (input_location
, OPT_pedantic
, "redeclaration of %<wchar_t%> as %qT",
735 /* Throw away the redeclaration. */
736 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
740 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
742 /* If the redeclaration failed, we can stop at this
744 if (olddecl
== error_mark_node
)
745 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
749 if (TREE_CODE (t
) == TYPE_DECL
)
750 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
752 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
754 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
756 /* A redeclaration of main, but not a duplicate of the
761 This function shall not be overloaded. */
762 error ("invalid redeclaration of %q+D", t
);
764 /* We don't try to push this declaration since that
766 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
771 /* If x has C linkage-specification, (extern "C"),
772 lookup its binding, in case it's already bound to an object.
773 The lookup is done in all namespaces.
774 If we find an existing binding, make sure it has the same
775 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
776 if ((TREE_CODE (x
) == FUNCTION_DECL
)
777 && DECL_EXTERN_C_P (x
)
778 /* We should ignore declarations happening in system headers. */
779 && !DECL_ARTIFICIAL (x
)
780 && !DECL_IN_SYSTEM_HEADER (x
))
782 cxx_binding
*function_binding
=
783 lookup_extern_c_fun_binding_in_all_ns (x
);
784 tree previous
= (function_binding
785 ? function_binding
->value
788 && !DECL_ARTIFICIAL (previous
)
789 && !DECL_IN_SYSTEM_HEADER (previous
)
790 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
792 tree previous
= function_binding
->value
;
794 /* In case either x or previous is declared to throw an exception,
795 make sure both exception specifications are equal. */
796 if (decls_match (x
, previous
))
798 tree x_exception_spec
= NULL_TREE
;
799 tree previous_exception_spec
= NULL_TREE
;
802 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
803 previous_exception_spec
=
804 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
805 if (!comp_except_specs (previous_exception_spec
,
809 pedwarn (input_location
, 0, "declaration of %q#D with C language linkage",
811 pedwarn (input_location
, 0, "conflicts with previous declaration %q+#D",
813 pedwarn (input_location
, 0, "due to different exception specifications");
814 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
819 pedwarn (input_location
, 0,
820 "declaration of %q#D with C language linkage", x
);
821 pedwarn (input_location
, 0,
822 "conflicts with previous declaration %q+#D",
828 check_template_shadow (x
);
830 /* If this is a function conjured up by the back end, massage it
831 so it looks friendly. */
832 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
834 retrofit_lang_decl (x
);
835 SET_DECL_LANGUAGE (x
, lang_c
);
839 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
841 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
842 if (!namespace_bindings_p ())
843 /* We do not need to create a binding for this name;
844 push_overloaded_decl will have already done so if
846 need_new_binding
= 0;
848 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
850 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
852 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
855 if (TREE_CODE (t
) == FUNCTION_DECL
|| DECL_FUNCTION_TEMPLATE_P (t
))
856 check_default_args (t
);
858 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
859 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
861 /* If declaring a type as a typedef, copy the type (unless we're
862 at line 0), and install this TYPE_DECL as the new type's typedef
863 name. See the extensive comment of set_underlying_type (). */
864 if (TREE_CODE (x
) == TYPE_DECL
)
866 tree type
= TREE_TYPE (x
);
868 if (DECL_IS_BUILTIN (x
)
869 || (TREE_TYPE (x
) != error_mark_node
870 && TYPE_NAME (type
) != x
871 /* We don't want to copy the type when all we're
872 doing is making a TYPE_DECL for the purposes of
874 && (!TYPE_NAME (type
)
875 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
876 set_underlying_type (x
);
878 if (type
!= error_mark_node
880 && TYPE_IDENTIFIER (type
))
881 set_identifier_type_value (DECL_NAME (x
), x
);
884 /* Multiple external decls of the same identifier ought to match.
886 We get warnings about inline functions where they are defined.
887 We get warnings about other functions from push_overloaded_decl.
889 Avoid duplicate warnings where they are used. */
890 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
894 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
895 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
896 decl
= OVL_FUNCTION (decl
);
898 if (decl
&& decl
!= error_mark_node
899 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
900 /* If different sort of thing, we already gave an error. */
901 && TREE_CODE (decl
) == TREE_CODE (x
)
902 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
904 permerror (input_location
, "type mismatch with previous external decl of %q#D", x
);
905 permerror (input_location
, "previous external decl of %q+#D", decl
);
909 if (TREE_CODE (x
) == FUNCTION_DECL
911 && !flag_friend_injection
)
913 /* This is a new declaration of a friend function, so hide
914 it from ordinary function lookup. */
915 DECL_ANTICIPATED (x
) = 1;
916 DECL_HIDDEN_FRIEND_P (x
) = 1;
919 /* This name is new in its binding level.
920 Install the new declaration and return it. */
921 if (namespace_bindings_p ())
923 /* Install a global value. */
925 /* If the first global decl has external linkage,
926 warn if we later see static one. */
927 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
928 TREE_PUBLIC (name
) = 1;
930 /* Bind the name for the entity. */
931 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
933 && (TREE_CODE (x
) == TYPE_DECL
934 || TREE_CODE (x
) == VAR_DECL
935 || TREE_CODE (x
) == NAMESPACE_DECL
936 || TREE_CODE (x
) == CONST_DECL
937 || TREE_CODE (x
) == TEMPLATE_DECL
))
938 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
940 /* If new decl is `static' and an `extern' was seen previously,
942 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
943 warn_extern_redeclared_static (x
, t
);
947 /* Here to install a non-global value. */
948 tree oldlocal
= innermost_non_namespace_value (name
);
949 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
951 if (need_new_binding
)
953 push_local_binding (name
, x
, 0);
954 /* Because push_local_binding will hook X on to the
955 current_binding_level's name list, we don't want to
956 do that again below. */
957 need_new_binding
= 0;
960 /* If this is a TYPE_DECL, push it into the type value slot. */
961 if (TREE_CODE (x
) == TYPE_DECL
)
962 set_identifier_type_value (name
, x
);
964 /* Clear out any TYPE_DECL shadowed by a namespace so that
965 we won't think this is a type. The C struct hack doesn't
966 go through namespaces. */
967 if (TREE_CODE (x
) == NAMESPACE_DECL
)
968 set_identifier_type_value (name
, NULL_TREE
);
975 && TREE_CODE (oldlocal
) == VAR_DECL
976 && DECL_DEAD_FOR_LOCAL (oldlocal
))
977 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
979 if (oldlocal
== NULL_TREE
)
980 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
983 /* If this is an extern function declaration, see if we
984 have a global definition or declaration for the function. */
985 if (oldlocal
== NULL_TREE
987 && oldglobal
!= NULL_TREE
988 && TREE_CODE (x
) == FUNCTION_DECL
989 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
991 /* We have one. Their types must agree. */
992 if (decls_match (x
, oldglobal
))
996 warning (0, "extern declaration of %q#D doesn%'t match", x
);
997 warning (0, "global declaration %q+#D", oldglobal
);
1000 /* If we have a local external declaration,
1001 and no file-scope declaration has yet been seen,
1002 then if we later have a file-scope decl it must not be static. */
1003 if (oldlocal
== NULL_TREE
1004 && oldglobal
== NULL_TREE
1005 && DECL_EXTERNAL (x
)
1007 TREE_PUBLIC (name
) = 1;
1009 /* Don't complain about the parms we push and then pop
1010 while tentatively parsing a function declarator. */
1011 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1014 /* Warn if shadowing an argument at the top level of the body. */
1015 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1016 /* Inline decls shadow nothing. */
1017 && !DECL_FROM_INLINE (x
)
1018 && (TREE_CODE (oldlocal
) == PARM_DECL
1019 || TREE_CODE (oldlocal
) == VAR_DECL
1020 /* If the old decl is a type decl, only warn if the
1021 old decl is an explicit typedef or if both the old
1022 and new decls are type decls. */
1023 || (TREE_CODE (oldlocal
) == TYPE_DECL
1024 && (!DECL_ARTIFICIAL (oldlocal
)
1025 || TREE_CODE (x
) == TYPE_DECL
)))
1026 /* Don't check the `this' parameter or internally generated
1027 vars unless it's an implicit typedef (see
1028 create_implicit_typedef in decl.c). */
1029 && (!DECL_ARTIFICIAL (oldlocal
)
1030 || DECL_IMPLICIT_TYPEDEF_P (oldlocal
))
1031 /* Don't check for internally generated vars unless
1032 it's an implicit typedef (see create_implicit_typedef
1034 && (!DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
)))
1036 bool nowarn
= false;
1038 /* Don't complain if it's from an enclosing function. */
1039 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1040 && TREE_CODE (x
) != PARM_DECL
1041 && TREE_CODE (oldlocal
) == PARM_DECL
)
1043 /* Go to where the parms should be and see if we find
1045 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
1047 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1048 /* Skip the ctor/dtor cleanup level. */
1052 if (b
->kind
== sk_function_parms
)
1054 error ("declaration of %q#D shadows a parameter", x
);
1059 /* The local structure or class can't use parameters of
1060 the containing function anyway. */
1061 if (DECL_CONTEXT (oldlocal
) != current_function_decl
)
1063 cxx_scope
*scope
= current_binding_level
;
1064 tree context
= DECL_CONTEXT (oldlocal
);
1065 for (; scope
; scope
= scope
->level_chain
)
1067 if (scope
->kind
== sk_function_parms
1068 && scope
->this_entity
== context
)
1070 if (scope
->kind
== sk_class
1071 && !LAMBDA_TYPE_P (scope
->this_entity
))
1079 if (warn_shadow
&& !nowarn
)
1081 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1082 warning_at (input_location
, OPT_Wshadow
,
1083 "declaration of %q#D shadows a parameter", x
);
1085 warning_at (input_location
, OPT_Wshadow
,
1086 "declaration of %qD shadows a previous local",
1088 warning_at (DECL_SOURCE_LOCATION (oldlocal
), OPT_Wshadow
,
1089 "shadowed declaration is here");
1093 /* Maybe warn if shadowing something else. */
1094 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1095 /* No shadow warnings for internally generated vars unless
1096 it's an implicit typedef (see create_implicit_typedef
1098 && (! DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
))
1099 /* No shadow warnings for vars made for inlining. */
1100 && ! DECL_FROM_INLINE (x
))
1104 if (current_class_ptr
)
1105 member
= lookup_member (current_class_type
,
1108 /*want_type=*/false);
1112 if (member
&& !TREE_STATIC (member
))
1114 /* Location of previous decl is not useful in this case. */
1115 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
1118 else if (oldglobal
!= NULL_TREE
1119 && (TREE_CODE (oldglobal
) == VAR_DECL
1120 /* If the old decl is a type decl, only warn if the
1121 old decl is an explicit typedef or if both the
1122 old and new decls are type decls. */
1123 || (TREE_CODE (oldglobal
) == TYPE_DECL
1124 && (!DECL_ARTIFICIAL (oldglobal
)
1125 || TREE_CODE (x
) == TYPE_DECL
))))
1126 /* XXX shadow warnings in outer-more namespaces */
1128 warning_at (input_location
, OPT_Wshadow
,
1129 "declaration of %qD shadows a global declaration", x
);
1130 warning_at (DECL_SOURCE_LOCATION (oldglobal
), OPT_Wshadow
,
1131 "shadowed declaration is here");
1136 if (TREE_CODE (x
) == VAR_DECL
)
1137 maybe_register_incomplete_var (x
);
1140 if (need_new_binding
)
1141 add_decl_to_level (x
,
1142 DECL_NAMESPACE_SCOPE_P (x
)
1143 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1144 : current_binding_level
);
1146 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1149 /* Record a decl-node X as belonging to the current lexical scope. */
1154 return pushdecl_maybe_friend (x
, false);
1157 /* Enter DECL into the symbol table, if that's appropriate. Returns
1158 DECL, or a modified version thereof. */
1161 maybe_push_decl (tree decl
)
1163 tree type
= TREE_TYPE (decl
);
1165 /* Add this decl to the current binding level, but not if it comes
1166 from another scope, e.g. a static member variable. TEM may equal
1167 DECL or it may be a previous decl of the same name. */
1168 if (decl
== error_mark_node
1169 || (TREE_CODE (decl
) != PARM_DECL
1170 && DECL_CONTEXT (decl
) != NULL_TREE
1171 /* Definitions of namespace members outside their namespace are
1173 && !DECL_NAMESPACE_SCOPE_P (decl
))
1174 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1175 || type
== unknown_type_node
1176 /* The declaration of a template specialization does not affect
1177 the functions available for overload resolution, so we do not
1179 || (TREE_CODE (decl
) == FUNCTION_DECL
1180 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1183 return pushdecl (decl
);
1186 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1187 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1188 doesn't really belong to this binding level, that it got here
1189 through a using-declaration. */
1192 push_local_binding (tree id
, tree decl
, int flags
)
1194 struct cp_binding_level
*b
;
1196 /* Skip over any local classes. This makes sense if we call
1197 push_local_binding with a friend decl of a local class. */
1198 b
= innermost_nonclass_level ();
1200 if (lookup_name_innermost_nonclass_level (id
))
1202 /* Supplement the existing binding. */
1203 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1204 /* It didn't work. Something else must be bound at this
1205 level. Do not add DECL to the list of things to pop
1210 /* Create a new binding. */
1211 push_binding (id
, decl
, b
);
1213 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1214 /* We must put the OVERLOAD into a TREE_LIST since the
1215 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1216 decls that got here through a using-declaration. */
1217 decl
= build_tree_list (NULL_TREE
, decl
);
1219 /* And put DECL on the list of things declared by the current
1221 add_decl_to_level (decl
, b
);
1224 /* Check to see whether or not DECL is a variable that would have been
1225 in scope under the ARM, but is not in scope under the ANSI/ISO
1226 standard. If so, issue an error message. If name lookup would
1227 work in both cases, but return a different result, this function
1228 returns the result of ANSI/ISO lookup. Otherwise, it returns
1232 check_for_out_of_scope_variable (tree decl
)
1236 /* We only care about out of scope variables. */
1237 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1240 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1241 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1242 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1243 && DECL_DEAD_FOR_LOCAL (shadowed
))
1244 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1245 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1247 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1250 if (!DECL_ERROR_REPORTED (decl
))
1252 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1253 warning (0, " matches this %q+D under ISO standard rules",
1255 warning (0, " matches this %q+D under old rules", decl
);
1256 DECL_ERROR_REPORTED (decl
) = 1;
1261 /* If we have already complained about this declaration, there's no
1262 need to do it again. */
1263 if (DECL_ERROR_REPORTED (decl
))
1266 DECL_ERROR_REPORTED (decl
) = 1;
1268 if (TREE_TYPE (decl
) == error_mark_node
)
1271 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1273 error ("name lookup of %qD changed for ISO %<for%> scoping",
1275 error (" cannot use obsolete binding at %q+D because "
1276 "it has a destructor", decl
);
1277 return error_mark_node
;
1281 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1283 if (flag_permissive
)
1284 permerror (input_location
, " using obsolete binding at %q+D", decl
);
1290 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1299 /* true means unconditionally make a BLOCK for the next level pushed. */
1301 static bool keep_next_level_flag
;
1303 static int binding_depth
= 0;
1310 for (i
= 0; i
< depth
* 2; i
++)
1314 /* Return a string describing the kind of SCOPE we have. */
1316 cxx_scope_descriptor (cxx_scope
*scope
)
1318 /* The order of this table must match the "scope_kind"
1320 static const char* scope_kind_names
[] = {
1326 "function-parameter-scope",
1329 "template-parameter-scope",
1330 "template-explicit-spec-scope"
1332 const scope_kind kind
= scope
->explicit_spec_p
1333 ? sk_template_spec
: scope
->kind
;
1335 return scope_kind_names
[kind
];
1338 /* Output a debugging information about SCOPE when performing
1341 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1343 const char *desc
= cxx_scope_descriptor (scope
);
1344 if (scope
->this_entity
)
1345 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1346 scope
->this_entity
, (void *) scope
, line
);
1348 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1351 /* Return the estimated initial size of the hashtable of a NAMESPACE
1354 static inline size_t
1355 namespace_scope_ht_size (tree ns
)
1357 tree name
= DECL_NAME (ns
);
1359 return name
== std_identifier
1360 ? NAMESPACE_STD_HT_SIZE
1361 : (name
== global_scope_name
1362 ? GLOBAL_SCOPE_HT_SIZE
1363 : NAMESPACE_ORDINARY_HT_SIZE
);
1366 /* A chain of binding_level structures awaiting reuse. */
1368 static GTY((deletable
)) struct cp_binding_level
*free_binding_level
;
1370 /* Insert SCOPE as the innermost binding level. */
1373 push_binding_level (struct cp_binding_level
*scope
)
1375 /* Add it to the front of currently active scopes stack. */
1376 scope
->level_chain
= current_binding_level
;
1377 current_binding_level
= scope
;
1378 keep_next_level_flag
= false;
1380 if (ENABLE_SCOPE_CHECKING
)
1382 scope
->binding_depth
= binding_depth
;
1383 indent (binding_depth
);
1384 cxx_scope_debug (scope
, input_line
, "push");
1389 /* Create a new KIND scope and make it the top of the active scopes stack.
1390 ENTITY is the scope of the associated C++ entity (namespace, class,
1391 function, C++0x enumeration); it is NULL otherwise. */
1394 begin_scope (scope_kind kind
, tree entity
)
1398 /* Reuse or create a struct for this binding level. */
1399 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1401 scope
= free_binding_level
;
1402 memset (scope
, 0, sizeof (cxx_scope
));
1403 free_binding_level
= scope
->level_chain
;
1406 scope
= ggc_alloc_cleared_cxx_scope ();
1408 scope
->this_entity
= entity
;
1409 scope
->more_cleanups_ok
= true;
1416 case sk_template_spec
:
1417 scope
->explicit_spec_p
= true;
1418 kind
= sk_template_parms
;
1420 case sk_template_parms
:
1426 case sk_scoped_enum
:
1427 case sk_function_parms
:
1429 scope
->keep
= keep_next_level_flag
;
1433 NAMESPACE_LEVEL (entity
) = scope
;
1434 scope
->static_decls
=
1435 VEC_alloc (tree
, gc
,
1436 DECL_NAME (entity
) == std_identifier
1437 || DECL_NAME (entity
) == global_scope_name
1442 /* Should not happen. */
1448 push_binding_level (scope
);
1453 /* We're about to leave current scope. Pop the top of the stack of
1454 currently active scopes. Return the enclosing scope, now active. */
1459 cxx_scope
*scope
= current_binding_level
;
1461 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1462 current_binding_level
= class_binding_level
;
1464 /* We cannot leave a scope, if there are none left. */
1465 if (NAMESPACE_LEVEL (global_namespace
))
1466 gcc_assert (!global_scope_p (scope
));
1468 if (ENABLE_SCOPE_CHECKING
)
1470 indent (--binding_depth
);
1471 cxx_scope_debug (scope
, input_line
, "leave");
1474 /* Move one nesting level up. */
1475 current_binding_level
= scope
->level_chain
;
1477 /* Namespace-scopes are left most probably temporarily, not
1478 completely; they can be reopened later, e.g. in namespace-extension
1479 or any name binding activity that requires us to resume a
1480 namespace. For classes, we cache some binding levels. For other
1481 scopes, we just make the structure available for reuse. */
1482 if (scope
->kind
!= sk_namespace
1483 && scope
->kind
!= sk_class
)
1485 scope
->level_chain
= free_binding_level
;
1486 gcc_assert (!ENABLE_SCOPE_CHECKING
1487 || scope
->binding_depth
== binding_depth
);
1488 free_binding_level
= scope
;
1491 /* Find the innermost enclosing class scope, and reset
1492 CLASS_BINDING_LEVEL appropriately. */
1493 if (scope
->kind
== sk_class
)
1495 class_binding_level
= NULL
;
1496 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1497 if (scope
->kind
== sk_class
)
1499 class_binding_level
= scope
;
1504 return current_binding_level
;
1508 resume_scope (struct cp_binding_level
* b
)
1510 /* Resuming binding levels is meant only for namespaces,
1511 and those cannot nest into classes. */
1512 gcc_assert (!class_binding_level
);
1513 /* Also, resuming a non-directly nested namespace is a no-no. */
1514 gcc_assert (b
->level_chain
== current_binding_level
);
1515 current_binding_level
= b
;
1516 if (ENABLE_SCOPE_CHECKING
)
1518 b
->binding_depth
= binding_depth
;
1519 indent (binding_depth
);
1520 cxx_scope_debug (b
, input_line
, "resume");
1525 /* Return the innermost binding level that is not for a class scope. */
1528 innermost_nonclass_level (void)
1532 b
= current_binding_level
;
1533 while (b
->kind
== sk_class
)
1539 /* We're defining an object of type TYPE. If it needs a cleanup, but
1540 we're not allowed to add any more objects with cleanups to the current
1541 scope, create a new binding level. */
1544 maybe_push_cleanup_level (tree type
)
1546 if (type
!= error_mark_node
1547 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1548 && current_binding_level
->more_cleanups_ok
== 0)
1550 begin_scope (sk_cleanup
, NULL
);
1551 current_binding_level
->statement_list
= push_stmt_list ();
1555 /* Nonzero if we are currently in the global binding level. */
1558 global_bindings_p (void)
1560 return global_scope_p (current_binding_level
);
1563 /* True if we are currently in a toplevel binding level. This
1564 means either the global binding level or a namespace in a toplevel
1565 binding level. Since there are no non-toplevel namespace levels,
1566 this really means any namespace or template parameter level. We
1567 also include a class whose context is toplevel. */
1570 toplevel_bindings_p (void)
1572 struct cp_binding_level
*b
= innermost_nonclass_level ();
1574 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1577 /* True if this is a namespace scope, or if we are defining a class
1578 which is itself at namespace scope, or whose enclosing class is
1579 such a class, etc. */
1582 namespace_bindings_p (void)
1584 struct cp_binding_level
*b
= innermost_nonclass_level ();
1586 return b
->kind
== sk_namespace
;
1589 /* True if the current level needs to have a BLOCK made. */
1594 return (current_binding_level
->blocks
!= NULL_TREE
1595 || current_binding_level
->keep
1596 || current_binding_level
->kind
== sk_cleanup
1597 || current_binding_level
->names
!= NULL_TREE
1598 || current_binding_level
->using_directives
);
1601 /* Returns the kind of the innermost scope. */
1604 innermost_scope_kind (void)
1606 return current_binding_level
->kind
;
1609 /* Returns true if this scope was created to store template parameters. */
1612 template_parm_scope_p (void)
1614 return innermost_scope_kind () == sk_template_parms
;
1617 /* If KEEP is true, make a BLOCK node for the next binding level,
1618 unconditionally. Otherwise, use the normal logic to decide whether
1619 or not to create a BLOCK. */
1622 keep_next_level (bool keep
)
1624 keep_next_level_flag
= keep
;
1627 /* Return the list of declarations of the current level.
1628 Note that this list is in reverse order unless/until
1629 you nreverse it; and when you do nreverse it, you must
1630 store the result back using `storedecls' or you will lose. */
1635 return current_binding_level
->names
;
1638 /* For debugging. */
1639 static int no_print_functions
= 0;
1640 static int no_print_builtins
= 0;
1643 print_binding_level (struct cp_binding_level
* lvl
)
1647 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1648 if (lvl
->more_cleanups_ok
)
1649 fprintf (stderr
, " more-cleanups-ok");
1650 if (lvl
->have_cleanups
)
1651 fprintf (stderr
, " have-cleanups");
1652 fprintf (stderr
, "\n");
1655 fprintf (stderr
, " names:\t");
1656 /* We can probably fit 3 names to a line? */
1657 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1659 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1661 if (no_print_builtins
1662 && (TREE_CODE (t
) == TYPE_DECL
)
1663 && DECL_IS_BUILTIN (t
))
1666 /* Function decls tend to have longer names. */
1667 if (TREE_CODE (t
) == FUNCTION_DECL
)
1674 fprintf (stderr
, "\n\t");
1677 print_node_brief (stderr
, "", t
, 0);
1678 if (t
== error_mark_node
)
1682 fprintf (stderr
, "\n");
1684 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1687 cp_class_binding
*b
;
1688 fprintf (stderr
, " class-shadowed:");
1689 FOR_EACH_VEC_ELT (cp_class_binding
, lvl
->class_shadowed
, i
, b
)
1690 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1691 fprintf (stderr
, "\n");
1693 if (lvl
->type_shadowed
)
1695 fprintf (stderr
, " type-shadowed:");
1696 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1698 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1700 fprintf (stderr
, "\n");
1705 print_other_binding_stack (struct cp_binding_level
*stack
)
1707 struct cp_binding_level
*level
;
1708 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1710 fprintf (stderr
, "binding level %p\n", (void *) level
);
1711 print_binding_level (level
);
1716 print_binding_stack (void)
1718 struct cp_binding_level
*b
;
1719 fprintf (stderr
, "current_binding_level=%p\n"
1720 "class_binding_level=%p\n"
1721 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1722 (void *) current_binding_level
, (void *) class_binding_level
,
1723 (void *) NAMESPACE_LEVEL (global_namespace
));
1724 if (class_binding_level
)
1726 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1727 if (b
== current_binding_level
)
1730 b
= class_binding_level
;
1732 b
= current_binding_level
;
1735 b
= current_binding_level
;
1736 print_other_binding_stack (b
);
1737 fprintf (stderr
, "global:\n");
1738 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1741 /* Return the type associated with id. */
1744 identifier_type_value (tree id
)
1746 timevar_push (TV_NAME_LOOKUP
);
1747 /* There is no type with that name, anywhere. */
1748 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1749 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1750 /* This is not the type marker, but the real thing. */
1751 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1752 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, REAL_IDENTIFIER_TYPE_VALUE (id
));
1753 /* Have to search for it. It must be on the global level, now.
1754 Ask lookup_name not to return non-types. */
1755 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1757 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, TREE_TYPE (id
));
1758 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1761 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1762 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1765 identifier_global_value (tree t
)
1767 return IDENTIFIER_GLOBAL_VALUE (t
);
1770 /* Push a definition of struct, union or enum tag named ID. into
1771 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1772 the tag ID is not already defined. */
1775 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1779 if (b
->kind
!= sk_namespace
)
1781 /* Shadow the marker, not the real thing, so that the marker
1782 gets restored later. */
1783 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1785 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1786 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1787 TREE_TYPE (b
->type_shadowed
) = type
;
1791 cxx_binding
*binding
=
1792 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1795 supplement_binding (binding
, decl
);
1797 binding
->value
= decl
;
1799 /* Store marker instead of real type. */
1800 type
= global_type_node
;
1802 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1805 /* As set_identifier_type_value_with_scope, but using
1806 current_binding_level. */
1809 set_identifier_type_value (tree id
, tree decl
)
1811 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1814 /* Return the name for the constructor (or destructor) for the
1815 specified class TYPE. When given a template, this routine doesn't
1816 lose the specialization. */
1819 constructor_name_full (tree type
)
1821 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1824 /* Return the name for the constructor (or destructor) for the
1825 specified class. When given a template, return the plain
1826 unspecialized name. */
1829 constructor_name (tree type
)
1832 name
= constructor_name_full (type
);
1833 if (IDENTIFIER_TEMPLATE (name
))
1834 name
= IDENTIFIER_TEMPLATE (name
);
1838 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1839 which must be a class type. */
1842 constructor_name_p (tree name
, tree type
)
1846 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
1851 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1854 ctor_name
= constructor_name_full (type
);
1855 if (name
== ctor_name
)
1857 if (IDENTIFIER_TEMPLATE (ctor_name
)
1858 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1863 /* Counter used to create anonymous type names. */
1865 static GTY(()) int anon_cnt
;
1867 /* Return an IDENTIFIER which can be used as a name for
1868 anonymous structs and unions. */
1871 make_anon_name (void)
1875 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1876 return get_identifier (buf
);
1879 /* This code is practically identical to that for creating
1880 anonymous names, but is just used for lambdas instead. This is necessary
1881 because anonymous names are recognized and cannot be passed to template
1883 /* FIXME is this still necessary? */
1885 static GTY(()) int lambda_cnt
= 0;
1888 make_lambda_name (void)
1892 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
1893 return get_identifier (buf
);
1896 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1898 static inline cxx_binding
*
1899 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1901 timevar_push (TV_NAME_LOOKUP
);
1903 for (; binding
!= NULL
; binding
= binding
->previous
)
1904 if (binding
->scope
== scope
)
1905 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
);
1907 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, (cxx_binding
*)0);
1910 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1912 static inline cxx_binding
*
1913 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1915 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1918 /* Fold-in case where NAME is used only once. */
1919 if (scope
== b
->scope
&& b
->previous
== NULL
)
1921 return find_binding (scope
, b
);
1926 /* Always returns a binding for name in scope. If no binding is
1927 found, make a new one. */
1929 static cxx_binding
*
1930 binding_for_name (cxx_scope
*scope
, tree name
)
1932 cxx_binding
*result
;
1934 result
= cxx_scope_find_binding_for_name (scope
, name
);
1937 /* Not found, make a new one. */
1938 result
= cxx_binding_make (NULL
, NULL
);
1939 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1940 result
->scope
= scope
;
1941 result
->is_local
= false;
1942 result
->value_is_inherited
= false;
1943 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1947 /* Walk through the bindings associated to the name of FUNCTION,
1948 and return the first binding that declares a function with a
1949 "C" linkage specification, a.k.a 'extern "C"'.
1950 This function looks for the binding, regardless of which scope it
1951 has been defined in. It basically looks in all the known scopes.
1952 Note that this function does not lookup for bindings of builtin functions
1953 or for functions declared in system headers. */
1955 lookup_extern_c_fun_binding_in_all_ns (tree function
)
1960 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
1962 name
= DECL_NAME (function
);
1963 gcc_assert (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
);
1965 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1967 iter
= iter
->previous
)
1970 && TREE_CODE (iter
->value
) == FUNCTION_DECL
1971 && DECL_EXTERN_C_P (iter
->value
)
1972 && !DECL_ARTIFICIAL (iter
->value
))
1980 /* Insert another USING_DECL into the current binding level, returning
1981 this declaration. If this is a redeclaration, do nothing, and
1982 return NULL_TREE if this not in namespace scope (in namespace
1983 scope, a using decl might extend any previous bindings). */
1986 push_using_decl (tree scope
, tree name
)
1990 timevar_push (TV_NAME_LOOKUP
);
1991 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
1992 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1993 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
1994 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
1997 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
1998 namespace_bindings_p () ? decl
: NULL_TREE
);
1999 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2000 USING_DECL_SCOPE (decl
) = scope
;
2001 DECL_CHAIN (decl
) = current_binding_level
->usings
;
2002 current_binding_level
->usings
= decl
;
2003 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2006 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2007 caller to set DECL_CONTEXT properly. */
2010 pushdecl_with_scope (tree x
, cxx_scope
*level
, bool is_friend
)
2012 struct cp_binding_level
*b
;
2013 tree function_decl
= current_function_decl
;
2015 timevar_push (TV_NAME_LOOKUP
);
2016 current_function_decl
= NULL_TREE
;
2017 if (level
->kind
== sk_class
)
2019 b
= class_binding_level
;
2020 class_binding_level
= level
;
2021 pushdecl_class_level (x
);
2022 class_binding_level
= b
;
2026 b
= current_binding_level
;
2027 current_binding_level
= level
;
2028 x
= pushdecl_maybe_friend (x
, is_friend
);
2029 current_binding_level
= b
;
2031 current_function_decl
= function_decl
;
2032 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
2035 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2036 other definitions already in place. We get around this by making
2037 the value of the identifier point to a list of all the things that
2038 want to be referenced by that name. It is then up to the users of
2039 that name to decide what to do with that list.
2041 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2042 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2044 FLAGS is a bitwise-or of the following values:
2045 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2047 PUSH_USING: DECL is being pushed as the result of a using
2050 IS_FRIEND is true if this is a friend declaration.
2052 The value returned may be a previous declaration if we guessed wrong
2053 about what language DECL should belong to (C or C++). Otherwise,
2054 it's always DECL (and never something that's not a _DECL). */
2057 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2059 tree name
= DECL_NAME (decl
);
2062 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2064 timevar_push (TV_NAME_LOOKUP
);
2066 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2068 old
= lookup_name_innermost_nonclass_level (name
);
2072 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2074 tree t
= TREE_TYPE (old
);
2075 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2076 && (! DECL_IN_SYSTEM_HEADER (decl
)
2077 || ! DECL_IN_SYSTEM_HEADER (old
)))
2078 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2081 else if (is_overloaded_fn (old
))
2085 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2087 tree fn
= OVL_CURRENT (tmp
);
2090 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2091 && !(flags
& PUSH_USING
)
2092 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2093 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
2094 && ! decls_match (fn
, decl
))
2095 error ("%q#D conflicts with previous using declaration %q#D",
2098 dup
= duplicate_decls (decl
, fn
, is_friend
);
2099 /* If DECL was a redeclaration of FN -- even an invalid
2100 one -- pass that information along to our caller. */
2101 if (dup
== fn
|| dup
== error_mark_node
)
2102 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, dup
);
2105 /* We don't overload implicit built-ins. duplicate_decls()
2106 may fail to merge the decls if the new decl is e.g. a
2107 template function. */
2108 if (TREE_CODE (old
) == FUNCTION_DECL
2109 && DECL_ANTICIPATED (old
)
2110 && !DECL_HIDDEN_FRIEND_P (old
))
2113 else if (old
== error_mark_node
)
2114 /* Ignore the undefined symbol marker. */
2118 error ("previous non-function declaration %q+#D", old
);
2119 error ("conflicts with function declaration %q#D", decl
);
2120 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2124 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2125 /* If it's a using declaration, we always need to build an OVERLOAD,
2126 because it's the only way to remember that the declaration comes
2127 from 'using', and have the lookup behave correctly. */
2128 || (flags
& PUSH_USING
))
2130 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2131 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2133 new_binding
= ovl_cons (decl
, old
);
2134 if (flags
& PUSH_USING
)
2135 OVL_USED (new_binding
) = 1;
2138 /* NAME is not ambiguous. */
2142 set_namespace_binding (name
, current_namespace
, new_binding
);
2145 /* We only create an OVERLOAD if there was a previous binding at
2146 this level, or if decl is a template. In the former case, we
2147 need to remove the old binding and replace it with the new
2148 binding. We must also run through the NAMES on the binding
2149 level where the name was bound to update the chain. */
2151 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2155 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2157 d
= &TREE_CHAIN (*d
))
2159 || (TREE_CODE (*d
) == TREE_LIST
2160 && TREE_VALUE (*d
) == old
))
2162 if (TREE_CODE (*d
) == TREE_LIST
)
2163 /* Just replace the old binding with the new. */
2164 TREE_VALUE (*d
) = new_binding
;
2166 /* Build a TREE_LIST to wrap the OVERLOAD. */
2167 *d
= tree_cons (NULL_TREE
, new_binding
,
2170 /* And update the cxx_binding node. */
2171 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2172 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2175 /* We should always find a previous binding in this case. */
2179 /* Install the new binding. */
2180 push_local_binding (name
, new_binding
, flags
);
2183 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2186 /* Check a non-member using-declaration. Return the name and scope
2187 being used, and the USING_DECL, or NULL_TREE on failure. */
2190 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2192 /* [namespace.udecl]
2193 A using-declaration for a class member shall be a
2194 member-declaration. */
2197 error ("%qT is not a namespace", scope
);
2200 else if (scope
== error_mark_node
)
2203 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2206 A using-declaration shall not name a template-id. */
2207 error ("a using-declaration cannot specify a template-id. "
2208 "Try %<using %D%>", name
);
2212 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2214 error ("namespace %qD not allowed in using-declaration", decl
);
2218 if (TREE_CODE (decl
) == SCOPE_REF
)
2220 /* It's a nested name with template parameter dependent scope.
2221 This can only be using-declaration for class member. */
2222 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2226 if (is_overloaded_fn (decl
))
2227 decl
= get_first_fn (decl
);
2229 gcc_assert (DECL_P (decl
));
2231 /* Make a USING_DECL. */
2232 return push_using_decl (scope
, name
);
2235 /* Process local and global using-declarations. */
2238 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2239 tree
*newval
, tree
*newtype
)
2241 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2243 *newval
= *newtype
= NULL_TREE
;
2244 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2248 if (!decls
.value
&& !decls
.type
)
2250 error ("%qD not declared", name
);
2254 /* Shift the old and new bindings around so we're comparing class and
2255 enumeration names to each other. */
2256 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2262 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2264 decls
.type
= decls
.value
;
2265 decls
.value
= NULL_TREE
;
2268 /* It is impossible to overload a built-in function; any explicit
2269 declaration eliminates the built-in declaration. So, if OLDVAL
2270 is a built-in, then we can just pretend it isn't there. */
2272 && TREE_CODE (oldval
) == FUNCTION_DECL
2273 && DECL_ANTICIPATED (oldval
)
2274 && !DECL_HIDDEN_FRIEND_P (oldval
))
2279 /* Check for using functions. */
2280 if (is_overloaded_fn (decls
.value
))
2284 if (oldval
&& !is_overloaded_fn (oldval
))
2286 error ("%qD is already declared in this scope", name
);
2291 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2293 tree new_fn
= OVL_CURRENT (tmp
);
2295 /* [namespace.udecl]
2297 If a function declaration in namespace scope or block
2298 scope has the same name and the same parameter types as a
2299 function introduced by a using declaration the program is
2301 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2303 tree old_fn
= OVL_CURRENT (tmp1
);
2305 if (new_fn
== old_fn
)
2306 /* The function already exists in the current namespace. */
2308 else if (OVL_USED (tmp1
))
2309 continue; /* this is a using decl */
2310 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2311 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2313 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2314 || DECL_HIDDEN_FRIEND_P (old_fn
));
2316 /* There was already a non-using declaration in
2317 this scope with the same parameter types. If both
2318 are the same extern "C" functions, that's ok. */
2319 if (decls_match (new_fn
, old_fn
))
2323 error ("%qD is already declared in this scope", name
);
2329 /* If we broke out of the loop, there's no reason to add
2330 this function to the using declarations for this
2335 /* If we are adding to an existing OVERLOAD, then we no
2336 longer know the type of the set of functions. */
2337 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2338 TREE_TYPE (*newval
) = unknown_type_node
;
2339 /* Add this new function to the set. */
2340 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2341 /* If there is only one function, then we use its type. (A
2342 using-declaration naming a single function can be used in
2343 contexts where overload resolution cannot be
2345 if (TREE_CODE (*newval
) != OVERLOAD
)
2347 *newval
= ovl_cons (*newval
, NULL_TREE
);
2348 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2350 OVL_USED (*newval
) = 1;
2355 *newval
= decls
.value
;
2356 if (oldval
&& !decls_match (*newval
, oldval
))
2357 error ("%qD is already declared in this scope", name
);
2363 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2365 error ("reference to %qD is ambiguous", name
);
2366 print_candidates (decls
.type
);
2370 *newtype
= decls
.type
;
2371 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2372 error ("%qD is already declared in this scope", name
);
2375 /* If *newval is empty, shift any class or enumeration name down. */
2379 *newtype
= NULL_TREE
;
2383 /* Process a using-declaration at function scope. */
2386 do_local_using_decl (tree decl
, tree scope
, tree name
)
2388 tree oldval
, oldtype
, newval
, newtype
;
2389 tree orig_decl
= decl
;
2391 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2392 if (decl
== NULL_TREE
)
2395 if (building_stmt_tree ()
2396 && at_function_scope_p ())
2397 add_decl_expr (decl
);
2399 oldval
= lookup_name_innermost_nonclass_level (name
);
2400 oldtype
= lookup_type_current_level (name
);
2402 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2406 if (is_overloaded_fn (newval
))
2410 /* We only need to push declarations for those functions
2411 that were not already bound in the current level.
2412 The old value might be NULL_TREE, it might be a single
2413 function, or an OVERLOAD. */
2414 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2415 term
= OVL_FUNCTION (oldval
);
2418 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2420 push_overloaded_decl (OVL_CURRENT (fn
),
2421 PUSH_LOCAL
| PUSH_USING
,
2425 push_local_binding (name
, newval
, PUSH_USING
);
2429 push_local_binding (name
, newtype
, PUSH_USING
);
2430 set_identifier_type_value (name
, newtype
);
2433 /* Emit debug info. */
2434 if (!processing_template_decl
)
2435 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2438 /* Returns true if ROOT (a namespace, class, or function) encloses
2439 CHILD. CHILD may be either a class type or a namespace. */
2442 is_ancestor (tree root
, tree child
)
2444 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2445 || TREE_CODE (root
) == FUNCTION_DECL
2446 || CLASS_TYPE_P (root
)));
2447 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2448 || CLASS_TYPE_P (child
)));
2450 /* The global namespace encloses everything. */
2451 if (root
== global_namespace
)
2456 /* If we've run out of scopes, stop. */
2459 /* If we've reached the ROOT, it encloses CHILD. */
2462 /* Go out one level. */
2464 child
= TYPE_NAME (child
);
2465 child
= DECL_CONTEXT (child
);
2469 /* Enter the class or namespace scope indicated by T suitable for name
2470 lookup. T can be arbitrary scope, not necessary nested inside the
2471 current scope. Returns a non-null scope to pop iff pop_scope
2472 should be called later to exit this scope. */
2477 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2478 push_decl_namespace (t
);
2479 else if (CLASS_TYPE_P (t
))
2481 if (!at_class_scope_p ()
2482 || !same_type_p (current_class_type
, t
))
2483 push_nested_class (t
);
2485 /* T is the same as the current scope. There is therefore no
2486 need to re-enter the scope. Since we are not actually
2487 pushing a new scope, our caller should not call
2495 /* Leave scope pushed by push_scope. */
2502 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2503 pop_decl_namespace ();
2504 else if CLASS_TYPE_P (t
)
2505 pop_nested_class ();
2508 /* Subroutine of push_inner_scope. */
2511 push_inner_scope_r (tree outer
, tree inner
)
2516 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2519 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2521 push_inner_scope_r (outer
, prev
);
2522 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2524 struct cp_binding_level
*save_template_parm
= 0;
2525 /* Temporary take out template parameter scopes. They are saved
2526 in reversed order in save_template_parm. */
2527 while (current_binding_level
->kind
== sk_template_parms
)
2529 struct cp_binding_level
*b
= current_binding_level
;
2530 current_binding_level
= b
->level_chain
;
2531 b
->level_chain
= save_template_parm
;
2532 save_template_parm
= b
;
2535 resume_scope (NAMESPACE_LEVEL (inner
));
2536 current_namespace
= inner
;
2538 /* Restore template parameter scopes. */
2539 while (save_template_parm
)
2541 struct cp_binding_level
*b
= save_template_parm
;
2542 save_template_parm
= b
->level_chain
;
2543 b
->level_chain
= current_binding_level
;
2544 current_binding_level
= b
;
2551 /* Enter the scope INNER from current scope. INNER must be a scope
2552 nested inside current scope. This works with both name lookup and
2553 pushing name into scope. In case a template parameter scope is present,
2554 namespace is pushed under the template parameter scope according to
2555 name lookup rule in 14.6.1/6.
2557 Return the former current scope suitable for pop_inner_scope. */
2560 push_inner_scope (tree inner
)
2562 tree outer
= current_scope ();
2564 outer
= current_namespace
;
2566 push_inner_scope_r (outer
, inner
);
2570 /* Exit the current scope INNER back to scope OUTER. */
2573 pop_inner_scope (tree outer
, tree inner
)
2576 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2579 while (outer
!= inner
)
2581 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2583 struct cp_binding_level
*save_template_parm
= 0;
2584 /* Temporary take out template parameter scopes. They are saved
2585 in reversed order in save_template_parm. */
2586 while (current_binding_level
->kind
== sk_template_parms
)
2588 struct cp_binding_level
*b
= current_binding_level
;
2589 current_binding_level
= b
->level_chain
;
2590 b
->level_chain
= save_template_parm
;
2591 save_template_parm
= b
;
2596 /* Restore template parameter scopes. */
2597 while (save_template_parm
)
2599 struct cp_binding_level
*b
= save_template_parm
;
2600 save_template_parm
= b
->level_chain
;
2601 b
->level_chain
= current_binding_level
;
2602 current_binding_level
= b
;
2608 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2612 /* Do a pushlevel for class declarations. */
2615 pushlevel_class (void)
2617 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2620 /* ...and a poplevel for class declarations. */
2623 poplevel_class (void)
2625 struct cp_binding_level
*level
= class_binding_level
;
2626 cp_class_binding
*cb
;
2630 timevar_push (TV_NAME_LOOKUP
);
2631 gcc_assert (level
!= 0);
2633 /* If we're leaving a toplevel class, cache its binding level. */
2634 if (current_class_depth
== 1)
2635 previous_class_level
= level
;
2636 for (shadowed
= level
->type_shadowed
;
2638 shadowed
= TREE_CHAIN (shadowed
))
2639 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2641 /* Remove the bindings for all of the class-level declarations. */
2642 if (level
->class_shadowed
)
2644 FOR_EACH_VEC_ELT (cp_class_binding
, level
->class_shadowed
, i
, cb
)
2645 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
.previous
;
2646 ggc_free (level
->class_shadowed
);
2647 level
->class_shadowed
= NULL
;
2650 /* Now, pop out of the binding level which we created up in the
2651 `pushlevel_class' routine. */
2652 gcc_assert (current_binding_level
== level
);
2654 timevar_pop (TV_NAME_LOOKUP
);
2657 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2658 appropriate. DECL is the value to which a name has just been
2659 bound. CLASS_TYPE is the class in which the lookup occurred. */
2662 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2665 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2669 if (TREE_CODE (decl
) == OVERLOAD
)
2670 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2673 gcc_assert (DECL_P (decl
));
2674 context
= context_for_name_lookup (decl
);
2677 if (is_properly_derived_from (class_type
, context
))
2678 INHERITED_VALUE_BINDING_P (binding
) = 1;
2680 INHERITED_VALUE_BINDING_P (binding
) = 0;
2682 else if (binding
->value
== decl
)
2683 /* We only encounter a TREE_LIST when there is an ambiguity in the
2684 base classes. Such an ambiguity can be overridden by a
2685 definition in this class. */
2686 INHERITED_VALUE_BINDING_P (binding
) = 1;
2688 INHERITED_VALUE_BINDING_P (binding
) = 0;
2691 /* Make the declaration of X appear in CLASS scope. */
2694 pushdecl_class_level (tree x
)
2697 bool is_valid
= true;
2699 /* Do nothing if we're adding to an outer lambda closure type,
2700 outer_binding will add it later if it's needed. */
2701 if (current_class_type
!= class_binding_level
->this_entity
)
2704 timevar_push (TV_NAME_LOOKUP
);
2705 /* Get the name of X. */
2706 if (TREE_CODE (x
) == OVERLOAD
)
2707 name
= DECL_NAME (get_first_fn (x
));
2709 name
= DECL_NAME (x
);
2713 is_valid
= push_class_level_binding (name
, x
);
2714 if (TREE_CODE (x
) == TYPE_DECL
)
2715 set_identifier_type_value (name
, x
);
2717 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2719 /* If X is an anonymous aggregate, all of its members are
2720 treated as if they were members of the class containing the
2721 aggregate, for naming purposes. */
2724 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= DECL_CHAIN (f
))
2726 location_t save_location
= input_location
;
2727 input_location
= DECL_SOURCE_LOCATION (f
);
2728 if (!pushdecl_class_level (f
))
2730 input_location
= save_location
;
2733 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, is_valid
);
2736 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2737 scope. If the value returned is non-NULL, and the PREVIOUS field
2738 is not set, callers must set the PREVIOUS field explicitly. */
2740 static cxx_binding
*
2741 get_class_binding (tree name
, cxx_scope
*scope
)
2746 cxx_binding
*binding
;
2748 class_type
= scope
->this_entity
;
2750 /* Get the type binding. */
2751 type_binding
= lookup_member (class_type
, name
,
2752 /*protect=*/2, /*want_type=*/true);
2753 /* Get the value binding. */
2754 value_binding
= lookup_member (class_type
, name
,
2755 /*protect=*/2, /*want_type=*/false);
2758 && (TREE_CODE (value_binding
) == TYPE_DECL
2759 || DECL_CLASS_TEMPLATE_P (value_binding
)
2760 || (TREE_CODE (value_binding
) == TREE_LIST
2761 && TREE_TYPE (value_binding
) == error_mark_node
2762 && (TREE_CODE (TREE_VALUE (value_binding
))
2764 /* We found a type binding, even when looking for a non-type
2765 binding. This means that we already processed this binding
2768 else if (value_binding
)
2770 if (TREE_CODE (value_binding
) == TREE_LIST
2771 && TREE_TYPE (value_binding
) == error_mark_node
)
2772 /* NAME is ambiguous. */
2774 else if (BASELINK_P (value_binding
))
2775 /* NAME is some overloaded functions. */
2776 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2779 /* If we found either a type binding or a value binding, create a
2780 new binding object. */
2781 if (type_binding
|| value_binding
)
2783 binding
= new_class_binding (name
,
2787 /* This is a class-scope binding, not a block-scope binding. */
2788 LOCAL_BINDING_P (binding
) = 0;
2789 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2797 /* Make the declaration(s) of X appear in CLASS scope under the name
2798 NAME. Returns true if the binding is valid. */
2801 push_class_level_binding (tree name
, tree x
)
2803 cxx_binding
*binding
;
2807 timevar_push (TV_NAME_LOOKUP
);
2808 /* The class_binding_level will be NULL if x is a template
2809 parameter name in a member template. */
2810 if (!class_binding_level
)
2811 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2813 if (name
== error_mark_node
)
2814 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2816 /* Check for invalid member names. */
2817 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2818 /* Check that we're pushing into the right binding level. */
2819 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
2821 /* We could have been passed a tree list if this is an ambiguous
2822 declaration. If so, pull the declaration out because
2823 check_template_shadow will not handle a TREE_LIST. */
2824 if (TREE_CODE (decl
) == TREE_LIST
2825 && TREE_TYPE (decl
) == error_mark_node
)
2826 decl
= TREE_VALUE (decl
);
2828 if (!check_template_shadow (decl
))
2829 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2833 If T is the name of a class, then each of the following shall
2834 have a name different from T:
2836 -- every static data member of class T;
2838 -- every member of class T that is itself a type;
2840 -- every enumerator of every member of class T that is an
2843 -- every member of every anonymous union that is a member of
2846 (Non-static data members were also forbidden to have the same
2847 name as T until TC1.) */
2848 if ((TREE_CODE (x
) == VAR_DECL
2849 || TREE_CODE (x
) == CONST_DECL
2850 || (TREE_CODE (x
) == TYPE_DECL
2851 && !DECL_SELF_REFERENCE_P (x
))
2852 /* A data member of an anonymous union. */
2853 || (TREE_CODE (x
) == FIELD_DECL
2854 && DECL_CONTEXT (x
) != current_class_type
))
2855 && DECL_NAME (x
) == constructor_name (current_class_type
))
2857 tree scope
= context_for_name_lookup (x
);
2858 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
2860 error ("%qD has the same name as the class in which it is "
2863 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2867 /* Get the current binding for NAME in this class, if any. */
2868 binding
= IDENTIFIER_BINDING (name
);
2869 if (!binding
|| binding
->scope
!= class_binding_level
)
2871 binding
= get_class_binding (name
, class_binding_level
);
2872 /* If a new binding was created, put it at the front of the
2873 IDENTIFIER_BINDING list. */
2876 binding
->previous
= IDENTIFIER_BINDING (name
);
2877 IDENTIFIER_BINDING (name
) = binding
;
2881 /* If there is already a binding, then we may need to update the
2883 if (binding
&& binding
->value
)
2885 tree bval
= binding
->value
;
2886 tree old_decl
= NULL_TREE
;
2888 if (INHERITED_VALUE_BINDING_P (binding
))
2890 /* If the old binding was from a base class, and was for a
2891 tag name, slide it over to make room for the new binding.
2892 The old binding is still visible if explicitly qualified
2893 with a class-key. */
2894 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2895 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2897 old_decl
= binding
->type
;
2898 binding
->type
= bval
;
2899 binding
->value
= NULL_TREE
;
2900 INHERITED_VALUE_BINDING_P (binding
) = 0;
2905 /* Any inherited type declaration is hidden by the type
2906 declaration in the derived class. */
2907 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
))
2908 binding
->type
= NULL_TREE
;
2911 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2913 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2914 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2915 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
2917 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
2918 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2920 if (old_decl
&& binding
->scope
== class_binding_level
)
2923 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2924 here. This function is only used to register bindings
2925 from with the class definition itself. */
2926 INHERITED_VALUE_BINDING_P (binding
) = 0;
2927 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2931 /* Note that we declared this value so that we can issue an error if
2932 this is an invalid redeclaration of a name already used for some
2934 note_name_declared_in_class (name
, decl
);
2936 /* If we didn't replace an existing binding, put the binding on the
2937 stack of bindings for the identifier, and update the shadowed
2939 if (binding
&& binding
->scope
== class_binding_level
)
2940 /* Supplement the existing binding. */
2941 ok
= supplement_binding (binding
, decl
);
2944 /* Create a new binding. */
2945 push_binding (name
, decl
, class_binding_level
);
2949 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
2952 /* Process "using SCOPE::NAME" in a class scope. Return the
2953 USING_DECL created. */
2956 do_class_using_decl (tree scope
, tree name
)
2958 /* The USING_DECL returned by this function. */
2960 /* The declaration (or declarations) name by this using
2961 declaration. NULL if we are in a template and cannot figure out
2962 what has been named. */
2964 /* True if SCOPE is a dependent type. */
2965 bool scope_dependent_p
;
2966 /* True if SCOPE::NAME is dependent. */
2967 bool name_dependent_p
;
2968 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2969 bool bases_dependent_p
;
2974 if (name
== error_mark_node
)
2977 if (!scope
|| !TYPE_P (scope
))
2979 error ("using-declaration for non-member at class scope");
2983 /* Make sure the name is not invalid */
2984 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2986 error ("%<%T::%D%> names destructor", scope
, name
);
2989 if (MAYBE_CLASS_TYPE_P (scope
) && constructor_name_p (name
, scope
))
2991 error ("%<%T::%D%> names constructor", scope
, name
);
2994 if (constructor_name_p (name
, current_class_type
))
2996 error ("%<%T::%D%> names constructor in %qT",
2997 scope
, name
, current_class_type
);
3001 scope_dependent_p
= dependent_type_p (scope
);
3002 name_dependent_p
= (scope_dependent_p
3003 || (IDENTIFIER_TYPENAME_P (name
)
3004 && dependent_type_p (TREE_TYPE (name
))));
3006 bases_dependent_p
= false;
3007 if (processing_template_decl
)
3008 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3009 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
3011 if (dependent_type_p (TREE_TYPE (base_binfo
)))
3013 bases_dependent_p
= true;
3019 /* From [namespace.udecl]:
3021 A using-declaration used as a member-declaration shall refer to a
3022 member of a base class of the class being defined.
3024 In general, we cannot check this constraint in a template because
3025 we do not know the entire set of base classes of the current
3026 class type. However, if all of the base classes are
3027 non-dependent, then we can avoid delaying the check until
3029 if (!scope_dependent_p
)
3032 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
3033 if (b_kind
< bk_proper_base
)
3035 if (!bases_dependent_p
)
3037 error_not_base_type (scope
, current_class_type
);
3041 else if (!name_dependent_p
)
3043 decl
= lookup_member (binfo
, name
, 0, false);
3046 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
3050 /* The binfo from which the functions came does not matter. */
3051 if (BASELINK_P (decl
))
3052 decl
= BASELINK_FUNCTIONS (decl
);
3056 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3057 USING_DECL_DECLS (value
) = decl
;
3058 USING_DECL_SCOPE (value
) = scope
;
3059 DECL_DEPENDENT_P (value
) = !decl
;
3065 /* Return the binding value for name in scope. */
3068 namespace_binding (tree name
, tree scope
)
3070 cxx_binding
*binding
;
3072 if (SCOPE_FILE_SCOPE_P (scope
))
3073 scope
= global_namespace
;
3075 /* Unnecessary for the global namespace because it can't be an alias. */
3076 scope
= ORIGINAL_NAMESPACE (scope
);
3078 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3080 return binding
? binding
->value
: NULL_TREE
;
3083 /* Set the binding value for name in scope. */
3086 set_namespace_binding (tree name
, tree scope
, tree val
)
3090 timevar_push (TV_NAME_LOOKUP
);
3091 if (scope
== NULL_TREE
)
3092 scope
= global_namespace
;
3093 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3094 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3097 supplement_binding (b
, val
);
3098 timevar_pop (TV_NAME_LOOKUP
);
3101 /* Set the context of a declaration to scope. Complain if we are not
3105 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3109 /* Get rid of namespace aliases. */
3110 scope
= ORIGINAL_NAMESPACE (scope
);
3112 /* It is ok for friends to be qualified in parallel space. */
3113 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3114 error ("declaration of %qD not in a namespace surrounding %qD",
3116 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3118 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3119 if (scope
== current_namespace
)
3121 if (at_namespace_scope_p ())
3122 error ("explicit qualification in declaration of %qD",
3127 /* See whether this has been declared in the namespace. */
3128 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3129 if (old
== error_mark_node
)
3130 /* No old declaration at all. */
3132 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3133 if (TREE_CODE (old
) == TREE_LIST
)
3135 error ("reference to %qD is ambiguous", decl
);
3136 print_candidates (old
);
3139 if (!is_overloaded_fn (decl
))
3141 /* We might have found OLD in an inline namespace inside SCOPE. */
3142 if (TREE_CODE (decl
) == TREE_CODE (old
))
3143 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3144 /* Don't compare non-function decls with decls_match here, since
3145 it can't check for the correct constness at this
3146 point. pushdecl will find those errors later. */
3149 /* Since decl is a function, old should contain a function decl. */
3150 if (!is_overloaded_fn (old
))
3152 /* A template can be explicitly specialized in any namespace. */
3153 if (processing_explicit_instantiation
)
3155 if (processing_template_decl
|| processing_specialization
)
3156 /* We have not yet called push_template_decl to turn a
3157 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3158 match. But, we'll check later, when we construct the
3161 /* Instantiations or specializations of templates may be declared as
3162 friends in any namespace. */
3163 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3165 if (is_overloaded_fn (old
))
3167 tree found
= NULL_TREE
;
3169 for (; elt
; elt
= OVL_NEXT (elt
))
3171 tree ofn
= OVL_CURRENT (elt
);
3172 /* Adjust DECL_CONTEXT first so decls_match will return true
3173 if DECL will match a declaration in an inline namespace. */
3174 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
3175 if (decls_match (decl
, ofn
))
3177 if (found
&& !decls_match (found
, ofn
))
3179 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3180 error ("reference to %qD is ambiguous", decl
);
3181 print_candidates (old
);
3189 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (found
)))
3191 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
3197 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3198 if (decls_match (decl
, old
))
3202 /* It didn't work, go back to the explicit scope. */
3203 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3205 error ("%qD should have been declared inside %qD", decl
, scope
);
3208 /* Return the namespace where the current declaration is declared. */
3211 current_decl_namespace (void)
3214 /* If we have been pushed into a different namespace, use it. */
3215 if (!VEC_empty (tree
, decl_namespace_list
))
3216 return VEC_last (tree
, decl_namespace_list
);
3218 if (current_class_type
)
3219 result
= decl_namespace_context (current_class_type
);
3220 else if (current_function_decl
)
3221 result
= decl_namespace_context (current_function_decl
);
3223 result
= current_namespace
;
3227 /* Process any ATTRIBUTES on a namespace definition. Currently only
3228 attribute visibility is meaningful, which is a property of the syntactic
3229 block rather than the namespace as a whole, so we don't touch the
3230 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3233 handle_namespace_attrs (tree ns
, tree attributes
)
3236 bool saw_vis
= false;
3238 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3240 tree name
= TREE_PURPOSE (d
);
3241 tree args
= TREE_VALUE (d
);
3243 if (is_attribute_p ("visibility", name
))
3245 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3246 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3248 warning (OPT_Wattributes
,
3249 "%qD attribute requires a single NTBS argument",
3254 if (!TREE_PUBLIC (ns
))
3255 warning (OPT_Wattributes
,
3256 "%qD attribute is meaningless since members of the "
3257 "anonymous namespace get local symbols", name
);
3259 push_visibility (TREE_STRING_POINTER (x
), 1);
3264 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3273 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3274 select a name that is unique to this compilation unit. */
3277 push_namespace (tree name
)
3281 int implicit_use
= 0;
3284 timevar_push (TV_NAME_LOOKUP
);
3286 /* We should not get here if the global_namespace is not yet constructed
3287 nor if NAME designates the global namespace: The global scope is
3288 constructed elsewhere. */
3289 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3293 name
= get_anonymous_namespace_name();
3294 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3296 /* Reopening anonymous namespace. */
3302 /* Check whether this is an extended namespace definition. */
3303 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3304 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3307 if (DECL_NAMESPACE_ALIAS (d
))
3309 error ("namespace alias %qD not allowed here, assuming %qD",
3310 d
, DECL_NAMESPACE_ALIAS (d
));
3311 d
= DECL_NAMESPACE_ALIAS (d
);
3318 /* Make a new namespace, binding the name to it. */
3319 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3320 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3321 /* The name of this namespace is not visible to other translation
3322 units if it is an anonymous namespace or member thereof. */
3323 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3324 TREE_PUBLIC (d
) = 0;
3326 TREE_PUBLIC (d
) = 1;
3330 /* Clear DECL_NAME for the benefit of debugging back ends. */
3331 SET_DECL_ASSEMBLER_NAME (d
, name
);
3332 DECL_NAME (d
) = NULL_TREE
;
3334 begin_scope (sk_namespace
, d
);
3337 resume_scope (NAMESPACE_LEVEL (d
));
3340 do_using_directive (d
);
3341 /* Enter the name space. */
3342 current_namespace
= d
;
3344 timevar_pop (TV_NAME_LOOKUP
);
3347 /* Pop from the scope of the current namespace. */
3350 pop_namespace (void)
3352 gcc_assert (current_namespace
!= global_namespace
);
3353 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3354 /* The binding level is not popped, as it might be re-opened later. */
3358 /* Push into the scope of the namespace NS, even if it is deeply
3359 nested within another namespace. */
3362 push_nested_namespace (tree ns
)
3364 if (ns
== global_namespace
)
3365 push_to_top_level ();
3368 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3369 push_namespace (DECL_NAME (ns
));
3373 /* Pop back from the scope of the namespace NS, which was previously
3374 entered with push_nested_namespace. */
3377 pop_nested_namespace (tree ns
)
3379 timevar_push (TV_NAME_LOOKUP
);
3380 gcc_assert (current_namespace
== ns
);
3381 while (ns
!= global_namespace
)
3384 ns
= CP_DECL_CONTEXT (ns
);
3387 pop_from_top_level ();
3388 timevar_pop (TV_NAME_LOOKUP
);
3391 /* Temporarily set the namespace for the current declaration. */
3394 push_decl_namespace (tree decl
)
3396 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3397 decl
= decl_namespace_context (decl
);
3398 VEC_safe_push (tree
, gc
, decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
3401 /* [namespace.memdef]/2 */
3404 pop_decl_namespace (void)
3406 VEC_pop (tree
, decl_namespace_list
);
3409 /* Return the namespace that is the common ancestor
3410 of two given namespaces. */
3413 namespace_ancestor (tree ns1
, tree ns2
)
3415 timevar_push (TV_NAME_LOOKUP
);
3416 if (is_ancestor (ns1
, ns2
))
3417 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ns1
);
3418 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
3419 namespace_ancestor (CP_DECL_CONTEXT (ns1
), ns2
));
3422 /* Process a namespace-alias declaration. */
3425 do_namespace_alias (tree alias
, tree name_space
)
3427 if (name_space
== error_mark_node
)
3430 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3432 name_space
= ORIGINAL_NAMESPACE (name_space
);
3434 /* Build the alias. */
3435 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3436 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3437 DECL_EXTERNAL (alias
) = 1;
3438 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3441 /* Emit debug info for namespace alias. */
3442 if (!building_stmt_tree ())
3443 (*debug_hooks
->global_decl
) (alias
);
3446 /* Like pushdecl, only it places X in the current namespace,
3450 pushdecl_namespace_level (tree x
, bool is_friend
)
3452 struct cp_binding_level
*b
= current_binding_level
;
3455 timevar_push (TV_NAME_LOOKUP
);
3456 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3458 /* Now, the type_shadowed stack may screw us. Munge it so it does
3460 if (TREE_CODE (t
) == TYPE_DECL
)
3462 tree name
= DECL_NAME (t
);
3464 tree
*ptr
= (tree
*)0;
3465 for (; !global_scope_p (b
); b
= b
->level_chain
)
3467 tree shadowed
= b
->type_shadowed
;
3468 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3469 if (TREE_PURPOSE (shadowed
) == name
)
3471 ptr
= &TREE_VALUE (shadowed
);
3472 /* Can't break out of the loop here because sometimes
3473 a binding level will have duplicate bindings for
3474 PT names. It's gross, but I haven't time to fix it. */
3477 newval
= TREE_TYPE (t
);
3478 if (ptr
== (tree
*)0)
3480 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3481 up here if this is changed to an assertion. --KR */
3482 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3489 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3492 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3493 directive is not directly from the source. Also find the common
3494 ancestor and let our users know about the new namespace */
3496 add_using_namespace (tree user
, tree used
, bool indirect
)
3499 timevar_push (TV_NAME_LOOKUP
);
3500 /* Using oneself is a no-op. */
3503 timevar_pop (TV_NAME_LOOKUP
);
3506 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3507 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3508 /* Check if we already have this. */
3509 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3513 /* Promote to direct usage. */
3514 TREE_INDIRECT_USING (t
) = 0;
3515 timevar_pop (TV_NAME_LOOKUP
);
3519 /* Add used to the user's using list. */
3520 DECL_NAMESPACE_USING (user
)
3521 = tree_cons (used
, namespace_ancestor (user
, used
),
3522 DECL_NAMESPACE_USING (user
));
3524 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3526 /* Add user to the used's users list. */
3527 DECL_NAMESPACE_USERS (used
)
3528 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3530 /* Recursively add all namespaces used. */
3531 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3532 /* indirect usage */
3533 add_using_namespace (user
, TREE_PURPOSE (t
), 1);
3535 /* Tell everyone using us about the new used namespaces. */
3536 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3537 add_using_namespace (TREE_PURPOSE (t
), used
, 1);
3538 timevar_pop (TV_NAME_LOOKUP
);
3541 /* Process a using-declaration not appearing in class or local scope. */
3544 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3546 tree oldval
, oldtype
, newval
, newtype
;
3547 tree orig_decl
= decl
;
3548 cxx_binding
*binding
;
3550 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3551 if (decl
== NULL_TREE
)
3554 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3556 oldval
= binding
->value
;
3557 oldtype
= binding
->type
;
3559 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3561 /* Emit debug info. */
3562 if (!processing_template_decl
)
3563 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3565 /* Copy declarations found. */
3567 binding
->value
= newval
;
3569 binding
->type
= newtype
;
3572 /* Process a using-directive. */
3575 do_using_directive (tree name_space
)
3577 tree context
= NULL_TREE
;
3579 if (name_space
== error_mark_node
)
3582 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3584 if (building_stmt_tree ())
3585 add_stmt (build_stmt (input_location
, USING_STMT
, name_space
));
3586 name_space
= ORIGINAL_NAMESPACE (name_space
);
3588 if (!toplevel_bindings_p ())
3590 push_using_directive (name_space
);
3595 add_using_namespace (current_namespace
, name_space
, 0);
3596 if (current_namespace
!= global_namespace
)
3597 context
= current_namespace
;
3599 /* Emit debugging info. */
3600 if (!processing_template_decl
)
3601 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
3606 /* Deal with a using-directive seen by the parser. Currently we only
3607 handle attributes here, since they cannot appear inside a template. */
3610 parse_using_directive (tree name_space
, tree attribs
)
3614 do_using_directive (name_space
);
3616 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3618 tree name
= TREE_PURPOSE (a
);
3619 if (is_attribute_p ("strong", name
))
3621 if (!toplevel_bindings_p ())
3622 error ("strong using only meaningful at namespace scope");
3623 else if (name_space
!= error_mark_node
)
3625 if (!is_ancestor (current_namespace
, name_space
))
3626 error ("current namespace %qD does not enclose strongly used namespace %qD",
3627 current_namespace
, name_space
);
3628 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
3629 = tree_cons (current_namespace
, 0,
3630 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
3634 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3638 /* Like pushdecl, only it places X in the global scope if appropriate.
3639 Calls cp_finish_decl to register the variable, initializing it with
3640 *INIT, if INIT is non-NULL. */
3643 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3645 timevar_push (TV_NAME_LOOKUP
);
3646 push_to_top_level ();
3647 x
= pushdecl_namespace_level (x
, is_friend
);
3649 cp_finish_decl (x
, *init
, false, NULL_TREE
, 0);
3650 pop_from_top_level ();
3651 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
3654 /* Like pushdecl, only it places X in the global scope if appropriate. */
3657 pushdecl_top_level (tree x
)
3659 return pushdecl_top_level_1 (x
, NULL
, false);
3662 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3665 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3667 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3670 /* Like pushdecl, only it places X in the global scope if
3671 appropriate. Calls cp_finish_decl to register the variable,
3672 initializing it with INIT. */
3675 pushdecl_top_level_and_finish (tree x
, tree init
)
3677 return pushdecl_top_level_1 (x
, &init
, false);
3680 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3681 duplicates. The first list becomes the tail of the result.
3683 The algorithm is O(n^2). We could get this down to O(n log n) by
3684 doing a sort on the addresses of the functions, if that becomes
3688 merge_functions (tree s1
, tree s2
)
3690 for (; s2
; s2
= OVL_NEXT (s2
))
3692 tree fn2
= OVL_CURRENT (s2
);
3695 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3697 tree fn1
= OVL_CURRENT (fns1
);
3699 /* If the function from S2 is already in S1, there is no
3700 need to add it again. For `extern "C"' functions, we
3701 might have two FUNCTION_DECLs for the same function, in
3702 different namespaces, but let's leave them in in case
3703 they have different default arguments. */
3708 /* If we exhausted all of the functions in S1, FN2 is new. */
3710 s1
= build_overload (fn2
, s1
);
3715 /* Returns TRUE iff OLD and NEW are the same entity.
3717 3 [basic]/3: An entity is a value, object, reference, function,
3718 enumerator, type, class member, template, template specialization,
3719 namespace, parameter pack, or this.
3721 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
3722 in two different namespaces, and the declarations do not declare the
3723 same entity and do not declare functions, the use of the name is
3727 same_entity_p (tree one
, tree two
)
3733 if (TREE_CODE (one
) == TYPE_DECL
3734 && TREE_CODE (two
) == TYPE_DECL
3735 && same_type_p (TREE_TYPE (one
), TREE_TYPE (two
)))
3740 /* This should return an error not all definitions define functions.
3741 It is not an error if we find two functions with exactly the
3742 same signature, only if these are selected in overload resolution.
3743 old is the current set of bindings, new_binding the freshly-found binding.
3744 XXX Do we want to give *all* candidates in case of ambiguity?
3745 XXX In what way should I treat extern declarations?
3746 XXX I don't want to repeat the entire duplicate_decls here */
3749 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
3752 gcc_assert (old
!= NULL
);
3754 /* Copy the type. */
3755 type
= new_binding
->type
;
3756 if (LOOKUP_NAMESPACES_ONLY (flags
)
3757 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
3760 /* Copy the value. */
3761 val
= new_binding
->value
;
3764 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
3767 switch (TREE_CODE (val
))
3770 /* If we expect types or namespaces, and not templates,
3771 or this is not a template class. */
3772 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3773 && !DECL_CLASS_TEMPLATE_P (val
)))
3777 if (LOOKUP_NAMESPACES_ONLY (flags
)
3778 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
3781 case NAMESPACE_DECL
:
3782 if (LOOKUP_TYPES_ONLY (flags
))
3786 /* Ignore built-in functions that are still anticipated. */
3787 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3791 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3796 /* If val is hidden, shift down any class or enumeration name. */
3805 else if (val
&& !same_entity_p (val
, old
->value
))
3807 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3808 old
->value
= merge_functions (old
->value
, val
);
3811 old
->value
= tree_cons (NULL_TREE
, old
->value
,
3812 build_tree_list (NULL_TREE
, val
));
3813 TREE_TYPE (old
->value
) = error_mark_node
;
3819 else if (type
&& old
->type
!= type
)
3821 old
->type
= tree_cons (NULL_TREE
, old
->type
,
3822 build_tree_list (NULL_TREE
, type
));
3823 TREE_TYPE (old
->type
) = error_mark_node
;
3827 /* Return the declarations that are members of the namespace NS. */
3830 cp_namespace_decls (tree ns
)
3832 return NAMESPACE_LEVEL (ns
)->names
;
3835 /* Combine prefer_type and namespaces_only into flags. */
3838 lookup_flags (int prefer_type
, int namespaces_only
)
3840 if (namespaces_only
)
3841 return LOOKUP_PREFER_NAMESPACES
;
3842 if (prefer_type
> 1)
3843 return LOOKUP_PREFER_TYPES
;
3844 if (prefer_type
> 0)
3845 return LOOKUP_PREFER_BOTH
;
3849 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3850 ignore it or not. Subroutine of lookup_name_real and
3851 lookup_type_scope. */
3854 qualify_lookup (tree val
, int flags
)
3856 if (val
== NULL_TREE
)
3858 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3860 if ((flags
& LOOKUP_PREFER_TYPES
)
3861 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3863 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
3865 /* In unevaluated context, look past normal capture fields. */
3866 if (cp_unevaluated_operand
&& TREE_CODE (val
) == FIELD_DECL
3867 && DECL_NORMAL_CAPTURE_P (val
))
3869 /* None of the lookups that use qualify_lookup want the op() from the
3870 lambda; they want the one from the enclosing class. */
3871 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))
3876 /* Given a lookup that returned VAL, decide if we want to ignore it or
3877 not based on DECL_ANTICIPATED. */
3880 hidden_name_p (tree val
)
3883 && DECL_LANG_SPECIFIC (val
)
3884 && DECL_ANTICIPATED (val
))
3889 /* Remove any hidden friend functions from a possibly overloaded set
3893 remove_hidden_names (tree fns
)
3898 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
3900 else if (TREE_CODE (fns
) == OVERLOAD
)
3904 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3905 if (hidden_name_p (OVL_CURRENT (o
)))
3911 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3912 if (!hidden_name_p (OVL_CURRENT (o
)))
3913 n
= build_overload (OVL_CURRENT (o
), n
);
3921 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
3922 lookup failed. Search through all available namespaces and print out
3923 possible candidates. */
3926 suggest_alternatives_for (location_t location
, tree name
)
3928 VEC(tree
,heap
) *candidates
= NULL
;
3929 VEC(tree
,heap
) *namespaces_to_search
= NULL
;
3930 int max_to_search
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
3935 VEC_safe_push (tree
, heap
, namespaces_to_search
, global_namespace
);
3937 while (!VEC_empty (tree
, namespaces_to_search
)
3938 && n_searched
< max_to_search
)
3940 tree scope
= VEC_pop (tree
, namespaces_to_search
);
3941 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3942 struct cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
3944 /* Look in this namespace. */
3945 qualified_lookup_using_namespace (name
, scope
, &binding
, 0);
3950 VEC_safe_push (tree
, heap
, candidates
, binding
.value
);
3952 /* Add child namespaces. */
3953 for (t
= level
->namespaces
; t
; t
= DECL_CHAIN (t
))
3954 VEC_safe_push (tree
, heap
, namespaces_to_search
, t
);
3957 /* If we stopped before we could examine all namespaces, inform the
3958 user. Do this even if we don't have any candidates, since there
3959 might be more candidates further down that we weren't able to
3961 if (n_searched
>= max_to_search
3962 && !VEC_empty (tree
, namespaces_to_search
))
3964 "maximum limit of %d namespaces searched for %qE",
3965 max_to_search
, name
);
3967 VEC_free (tree
, heap
, namespaces_to_search
);
3969 /* Nothing useful to report. */
3970 if (VEC_empty (tree
, candidates
))
3973 inform_n (location
, VEC_length (tree
, candidates
),
3974 "suggested alternative:",
3975 "suggested alternatives:");
3977 FOR_EACH_VEC_ELT (tree
, candidates
, ix
, t
)
3978 inform (location_of (t
), " %qE", t
);
3980 VEC_free (tree
, heap
, candidates
);
3983 /* Unscoped lookup of a global: iterate over current namespaces,
3984 considering using-directives. */
3987 unqualified_namespace_lookup (tree name
, int flags
)
3989 tree initial
= current_decl_namespace ();
3990 tree scope
= initial
;
3992 struct cp_binding_level
*level
;
3993 tree val
= NULL_TREE
;
3995 timevar_push (TV_NAME_LOOKUP
);
3997 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
3999 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4001 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4004 ambiguous_decl (&binding
, b
, flags
);
4006 /* Add all _DECLs seen through local using-directives. */
4007 for (level
= current_binding_level
;
4008 level
->kind
!= sk_namespace
;
4009 level
= level
->level_chain
)
4010 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
4012 /* Give up because of error. */
4013 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
4015 /* Add all _DECLs seen through global using-directives. */
4016 /* XXX local and global using lists should work equally. */
4020 if (!lookup_using_namespace (name
, &binding
,
4021 DECL_NAMESPACE_USING (siter
),
4023 /* Give up because of error. */
4024 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
4025 if (siter
== scope
) break;
4026 siter
= CP_DECL_CONTEXT (siter
);
4029 val
= binding
.value
;
4030 if (scope
== global_namespace
)
4033 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4036 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4037 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4040 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4041 declaration found. If no suitable declaration can be found,
4042 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4043 neither a class-type nor a namespace a diagnostic is issued. */
4046 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
4051 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
4053 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4055 flags
|= LOOKUP_COMPLAIN
;
4057 flags
|= LOOKUP_PREFER_TYPES
;
4058 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
4061 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
4062 t
= lookup_enumerator (scope
, name
);
4063 else if (is_class_type (scope
, complain
))
4064 t
= lookup_member (scope
, name
, 2, is_type_p
);
4067 return error_mark_node
;
4071 /* Subroutine of unqualified_namespace_lookup:
4072 Add the bindings of NAME in used namespaces to VAL.
4073 We are currently looking for names in namespace SCOPE, so we
4074 look through USINGS for using-directives of namespaces
4075 which have SCOPE as a common ancestor with the current scope.
4076 Returns false on errors. */
4079 lookup_using_namespace (tree name
, struct scope_binding
*val
,
4080 tree usings
, tree scope
, int flags
)
4083 timevar_push (TV_NAME_LOOKUP
);
4084 /* Iterate over all used namespaces in current, searching for using
4085 directives of scope. */
4086 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
4087 if (TREE_VALUE (iter
) == scope
)
4089 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
4091 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
4092 /* Resolve ambiguities. */
4094 ambiguous_decl (val
, val1
, flags
);
4096 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
->value
!= error_mark_node
);
4099 /* Returns true iff VEC contains TARGET. */
4102 tree_vec_contains (VEC(tree
,gc
)* vec
, tree target
)
4106 FOR_EACH_VEC_ELT (tree
,vec
,i
,elt
)
4113 Accepts the NAME to lookup and its qualifying SCOPE.
4114 Returns the name/type pair found into the cxx_binding *RESULT,
4115 or false on error. */
4118 qualified_lookup_using_namespace (tree name
, tree scope
,
4119 struct scope_binding
*result
, int flags
)
4121 /* Maintain a list of namespaces visited... */
4122 VEC(tree
,gc
) *seen
= NULL
;
4123 VEC(tree
,gc
) *seen_inline
= NULL
;
4124 /* ... and a list of namespace yet to see. */
4125 VEC(tree
,gc
) *todo
= NULL
;
4126 VEC(tree
,gc
) *todo_maybe
= NULL
;
4127 VEC(tree
,gc
) *todo_inline
= NULL
;
4129 timevar_push (TV_NAME_LOOKUP
);
4130 /* Look through namespace aliases. */
4131 scope
= ORIGINAL_NAMESPACE (scope
);
4133 /* Algorithm: Starting with SCOPE, walk through the the set of used
4134 namespaces. For each used namespace, look through its inline
4135 namespace set for any bindings and usings. If no bindings are found,
4136 add any usings seen to the set of used namespaces. */
4137 VEC_safe_push (tree
, gc
, todo
, scope
);
4139 while (VEC_length (tree
, todo
))
4142 scope
= VEC_pop (tree
, todo
);
4143 if (tree_vec_contains (seen
, scope
))
4145 VEC_safe_push (tree
, gc
, seen
, scope
);
4146 VEC_safe_push (tree
, gc
, todo_inline
, scope
);
4149 while (VEC_length (tree
, todo_inline
))
4151 cxx_binding
*binding
;
4153 scope
= VEC_pop (tree
, todo_inline
);
4154 if (tree_vec_contains (seen_inline
, scope
))
4156 VEC_safe_push (tree
, gc
, seen_inline
, scope
);
4159 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4163 ambiguous_decl (result
, binding
, flags
);
4166 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
4167 usings
= TREE_CHAIN (usings
))
4168 if (!TREE_INDIRECT_USING (usings
))
4170 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
)))
4171 VEC_safe_push (tree
, gc
, todo_inline
, TREE_PURPOSE (usings
));
4173 VEC_safe_push (tree
, gc
, todo_maybe
, TREE_PURPOSE (usings
));
4178 VEC_truncate (tree
, todo_maybe
, 0);
4180 while (VEC_length (tree
, todo_maybe
))
4181 VEC_safe_push (tree
, gc
, todo
, VEC_pop (tree
, todo_maybe
));
4183 VEC_free (tree
,gc
,todo
);
4184 VEC_free (tree
,gc
,todo_maybe
);
4185 VEC_free (tree
,gc
,todo_inline
);
4186 VEC_free (tree
,gc
,seen
);
4187 VEC_free (tree
,gc
,seen_inline
);
4188 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
->value
!= error_mark_node
);
4191 /* Subroutine of outer_binding.
4192 Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
4196 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
4201 if (!binding
|| !scope
)
4204 binding_value
= binding
->value
? binding
->value
: binding
->type
;
4207 && scope
->this_entity
4208 && get_template_info (scope
->this_entity
)
4209 && parameter_of_template_p (binding_value
,
4210 TI_TEMPLATE (get_template_info \
4211 (scope
->this_entity
))));
4214 /* Return the innermost non-namespace binding for NAME from a scope
4215 containing BINDING, or, if BINDING is NULL, the current scope.
4216 Please note that for a given template, the template parameters are
4217 considered to be in the scope containing the current scope.
4218 If CLASS_P is false, then class bindings are ignored. */
4221 outer_binding (tree name
,
4222 cxx_binding
*binding
,
4227 cxx_scope
*outer_scope
;
4231 scope
= binding
->scope
->level_chain
;
4232 outer
= binding
->previous
;
4236 scope
= current_binding_level
;
4237 outer
= IDENTIFIER_BINDING (name
);
4239 outer_scope
= outer
? outer
->scope
: NULL
;
4241 /* Because we create class bindings lazily, we might be missing a
4242 class binding for NAME. If there are any class binding levels
4243 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4244 declared, we must lookup NAME in those class scopes. */
4246 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4248 if (scope
->kind
== sk_class
)
4250 cxx_binding
*class_binding
;
4252 class_binding
= get_class_binding (name
, scope
);
4255 /* Thread this new class-scope binding onto the
4256 IDENTIFIER_BINDING list so that future lookups
4258 class_binding
->previous
= outer
;
4260 binding
->previous
= class_binding
;
4262 IDENTIFIER_BINDING (name
) = class_binding
;
4263 return class_binding
;
4266 /* If we are in a member template, the template parms of the member
4267 template are considered to be inside the scope of the containing
4268 class, but within G++ the class bindings are all pushed between the
4269 template parms and the function body. So if the outer binding is
4270 a template parm for the current scope, return it now rather than
4271 look for a class binding. */
4272 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4273 && binding_to_template_parms_of_scope_p (outer
, scope
))
4276 scope
= scope
->level_chain
;
4282 /* Return the innermost block-scope or class-scope value binding for
4283 NAME, or NULL_TREE if there is no such binding. */
4286 innermost_non_namespace_value (tree name
)
4288 cxx_binding
*binding
;
4289 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4290 return binding
? binding
->value
: NULL_TREE
;
4293 /* Look up NAME in the current binding level and its superiors in the
4294 namespace of variables, functions and typedefs. Return a ..._DECL
4295 node of some kind representing its definition if there is only one
4296 such declaration, or return a TREE_LIST with all the overloaded
4297 definitions if there are many, or return 0 if it is undefined.
4298 Hidden name, either friend declaration or built-in function, are
4301 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4302 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4303 Otherwise we prefer non-TYPE_DECLs.
4305 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4306 BLOCK_P is false, bindings in block scopes are ignored. */
4309 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4310 int namespaces_only
, int flags
)
4313 tree val
= NULL_TREE
;
4315 timevar_push (TV_NAME_LOOKUP
);
4316 /* Conversion operators are handled specially because ordinary
4317 unqualified name lookup will not find template conversion
4319 if (IDENTIFIER_TYPENAME_P (name
))
4321 struct cp_binding_level
*level
;
4323 for (level
= current_binding_level
;
4324 level
&& level
->kind
!= sk_namespace
;
4325 level
= level
->level_chain
)
4330 /* A conversion operator can only be declared in a class
4332 if (level
->kind
!= sk_class
)
4335 /* Lookup the conversion operator in the class. */
4336 class_type
= level
->this_entity
;
4337 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4339 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, operators
);
4342 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4345 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4347 /* First, look in non-namespace scopes. */
4349 if (current_class_type
== NULL_TREE
)
4352 if (block_p
|| !nonclass
)
4353 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4355 iter
= outer_binding (name
, iter
, !nonclass
))
4359 /* Skip entities we don't want. */
4360 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4363 /* If this is the kind of thing we're looking for, we're done. */
4364 if (qualify_lookup (iter
->value
, flags
))
4365 binding
= iter
->value
;
4366 else if ((flags
& LOOKUP_PREFER_TYPES
)
4367 && qualify_lookup (iter
->type
, flags
))
4368 binding
= iter
->type
;
4370 binding
= NULL_TREE
;
4374 if (hidden_name_p (binding
))
4376 /* A non namespace-scope binding can only be hidden in the
4377 presence of a local class, due to friend declarations.
4379 In particular, consider:
4387 B* b; // error: B is hidden
4388 C* c; // OK, finds ::C
4391 B *b; // error: B is hidden
4392 C *c; // OK, finds ::C
4397 The standard says that "B" is a local class in "f"
4398 (but not nested within "A") -- but that name lookup
4399 for "B" does not find this declaration until it is
4400 declared directly with "f".
4406 If a friend declaration appears in a local class and
4407 the name specified is an unqualified name, a prior
4408 declaration is looked up without considering scopes
4409 that are outside the innermost enclosing non-class
4410 scope. For a friend function declaration, if there is
4411 no prior declaration, the program is ill-formed. For a
4412 friend class declaration, if there is no prior
4413 declaration, the class that is specified belongs to the
4414 innermost enclosing non-class scope, but if it is
4415 subsequently referenced, its name is not found by name
4416 lookup until a matching declaration is provided in the
4417 innermost enclosing nonclass scope.
4419 So just keep looking for a non-hidden binding.
4421 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4429 /* Now lookup in namespace scopes. */
4431 val
= unqualified_namespace_lookup (name
, flags
);
4433 /* If we have a single function from a using decl, pull it out. */
4434 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4435 val
= OVL_FUNCTION (val
);
4437 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4441 lookup_name_nonclass (tree name
)
4443 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4447 lookup_function_nonclass (tree name
, VEC(tree
,gc
) *args
, bool block_p
)
4450 lookup_arg_dependent (name
,
4451 lookup_name_real (name
, 0, 1, block_p
, 0,
4457 lookup_name (tree name
)
4459 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4463 lookup_name_prefer_type (tree name
, int prefer_type
)
4465 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
4466 0, LOOKUP_COMPLAIN
);
4469 /* Look up NAME for type used in elaborated name specifier in
4470 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4471 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4472 name, more scopes are checked if cleanup or template parameter
4473 scope is encountered.
4475 Unlike lookup_name_real, we make sure that NAME is actually
4476 declared in the desired scope, not from inheritance, nor using
4477 directive. For using declaration, there is DR138 still waiting
4478 to be resolved. Hidden name coming from an earlier friend
4479 declaration is also returned.
4481 A TYPE_DECL best matching the NAME is returned. Catching error
4482 and issuing diagnostics are caller's responsibility. */
4485 lookup_type_scope (tree name
, tag_scope scope
)
4487 cxx_binding
*iter
= NULL
;
4488 tree val
= NULL_TREE
;
4490 timevar_push (TV_NAME_LOOKUP
);
4492 /* Look in non-namespace scope first. */
4493 if (current_binding_level
->kind
!= sk_namespace
)
4494 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4495 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4497 /* Check if this is the kind of thing we're looking for.
4498 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4499 base class. For ITER->VALUE, we can simply use
4500 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4503 We check ITER->TYPE before ITER->VALUE in order to handle
4504 typedef struct C {} C;
4507 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4508 && (scope
!= ts_current
4509 || LOCAL_BINDING_P (iter
)
4510 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4512 else if ((scope
!= ts_current
4513 || !INHERITED_VALUE_BINDING_P (iter
))
4514 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4521 /* Look in namespace scope. */
4524 iter
= cxx_scope_find_binding_for_name
4525 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4529 /* If this is the kind of thing we're looking for, we're done. */
4530 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4532 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4538 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4539 and template parameter scopes. */
4542 struct cp_binding_level
*b
= current_binding_level
;
4545 if (iter
->scope
== b
)
4546 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4548 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
4549 || b
->kind
== sk_function_parms
)
4551 else if (b
->kind
== sk_class
4552 && scope
== ts_within_enclosing_non_class
)
4559 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4562 /* Similar to `lookup_name' but look only in the innermost non-class
4566 lookup_name_innermost_nonclass_level (tree name
)
4568 struct cp_binding_level
*b
;
4571 timevar_push (TV_NAME_LOOKUP
);
4572 b
= innermost_nonclass_level ();
4574 if (b
->kind
== sk_namespace
)
4576 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4578 /* extern "C" function() */
4579 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4582 else if (IDENTIFIER_BINDING (name
)
4583 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4585 cxx_binding
*binding
;
4586 binding
= IDENTIFIER_BINDING (name
);
4589 if (binding
->scope
== b
4590 && !(TREE_CODE (binding
->value
) == VAR_DECL
4591 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4592 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
->value
);
4594 if (b
->kind
== sk_cleanup
)
4601 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4604 /* Returns true iff DECL is a block-scope extern declaration of a function
4608 is_local_extern (tree decl
)
4610 cxx_binding
*binding
;
4612 /* For functions, this is easy. */
4613 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4614 return DECL_LOCAL_FUNCTION_P (decl
);
4616 if (TREE_CODE (decl
) != VAR_DECL
)
4618 if (!current_function_decl
)
4621 /* For variables, this is not easy. We need to look at the binding stack
4622 for the identifier to see whether the decl we have is a local. */
4623 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
4624 binding
&& binding
->scope
->kind
!= sk_namespace
;
4625 binding
= binding
->previous
)
4626 if (binding
->value
== decl
)
4627 return LOCAL_BINDING_P (binding
);
4632 /* Like lookup_name_innermost_nonclass_level, but for types. */
4635 lookup_type_current_level (tree name
)
4639 timevar_push (TV_NAME_LOOKUP
);
4640 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4642 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4643 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4645 struct cp_binding_level
*b
= current_binding_level
;
4648 if (purpose_member (name
, b
->type_shadowed
))
4649 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
4650 REAL_IDENTIFIER_TYPE_VALUE (name
));
4651 if (b
->kind
== sk_cleanup
)
4658 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4661 /* [basic.lookup.koenig] */
4662 /* A nonzero return value in the functions below indicates an error. */
4668 VEC(tree
,gc
) *namespaces
;
4669 VEC(tree
,gc
) *classes
;
4673 static bool arg_assoc (struct arg_lookup
*, tree
);
4674 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4675 static bool arg_assoc_args_vec (struct arg_lookup
*, VEC(tree
,gc
) *);
4676 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4677 static bool add_function (struct arg_lookup
*, tree
);
4678 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4679 static bool arg_assoc_class_only (struct arg_lookup
*, tree
);
4680 static bool arg_assoc_bases (struct arg_lookup
*, tree
);
4681 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4682 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4684 /* Add a function to the lookup structure.
4685 Returns true on error. */
4688 add_function (struct arg_lookup
*k
, tree fn
)
4690 /* We used to check here to see if the function was already in the list,
4691 but that's O(n^2), which is just too expensive for function lookup.
4692 Now we deal with the occasional duplicate in joust. In doing this, we
4693 assume that the number of duplicates will be small compared to the
4694 total number of functions being compared, which should usually be the
4697 if (!is_overloaded_fn (fn
))
4698 /* All names except those of (possibly overloaded) functions and
4699 function templates are ignored. */;
4700 else if (!k
->functions
)
4702 else if (fn
== k
->functions
)
4705 k
->functions
= build_overload (fn
, k
->functions
);
4710 /* Returns true iff CURRENT has declared itself to be an associated
4711 namespace of SCOPE via a strong using-directive (or transitive chain
4712 thereof). Both are namespaces. */
4715 is_associated_namespace (tree current
, tree scope
)
4717 VEC(tree
,gc
) *seen
= make_tree_vector ();
4718 VEC(tree
,gc
) *todo
= make_tree_vector ();
4724 if (scope
== current
)
4729 VEC_safe_push (tree
, gc
, seen
, scope
);
4730 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4731 if (!vec_member (TREE_PURPOSE (t
), seen
))
4732 VEC_safe_push (tree
, gc
, todo
, TREE_PURPOSE (t
));
4733 if (!VEC_empty (tree
, todo
))
4735 scope
= VEC_last (tree
, todo
);
4736 VEC_pop (tree
, todo
);
4745 release_tree_vector (seen
);
4746 release_tree_vector (todo
);
4751 /* Add functions of a namespace to the lookup structure.
4752 Returns true on error. */
4755 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4759 if (vec_member (scope
, k
->namespaces
))
4761 VEC_safe_push (tree
, gc
, k
->namespaces
, scope
);
4763 /* Check out our super-users. */
4764 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4765 value
= TREE_CHAIN (value
))
4766 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4769 /* Also look down into inline namespaces. */
4770 for (value
= DECL_NAMESPACE_USING (scope
); value
;
4771 value
= TREE_CHAIN (value
))
4772 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
4773 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4776 value
= namespace_binding (k
->name
, scope
);
4780 for (; value
; value
= OVL_NEXT (value
))
4782 /* We don't want to find arbitrary hidden functions via argument
4783 dependent lookup. We only want to find friends of associated
4784 classes, which we'll do via arg_assoc_class. */
4785 if (hidden_name_p (OVL_CURRENT (value
)))
4788 if (add_function (k
, OVL_CURRENT (value
)))
4795 /* Adds everything associated with a template argument to the lookup
4796 structure. Returns true on error. */
4799 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4801 /* [basic.lookup.koenig]
4803 If T is a template-id, its associated namespaces and classes are
4804 ... the namespaces and classes associated with the types of the
4805 template arguments provided for template type parameters
4806 (excluding template template parameters); the namespaces in which
4807 any template template arguments are defined; and the classes in
4808 which any member templates used as template template arguments
4809 are defined. [Note: non-type template arguments do not
4810 contribute to the set of associated namespaces. ] */
4812 /* Consider first template template arguments. */
4813 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4814 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
4816 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
4818 tree ctx
= CP_DECL_CONTEXT (arg
);
4820 /* It's not a member template. */
4821 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4822 return arg_assoc_namespace (k
, ctx
);
4823 /* Otherwise, it must be member template. */
4825 return arg_assoc_class_only (k
, ctx
);
4827 /* It's an argument pack; handle it recursively. */
4828 else if (ARGUMENT_PACK_P (arg
))
4830 tree args
= ARGUMENT_PACK_ARGS (arg
);
4831 int i
, len
= TREE_VEC_LENGTH (args
);
4832 for (i
= 0; i
< len
; ++i
)
4833 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
4838 /* It's not a template template argument, but it is a type template
4840 else if (TYPE_P (arg
))
4841 return arg_assoc_type (k
, arg
);
4842 /* It's a non-type template argument. */
4847 /* Adds the class and its friends to the lookup structure.
4848 Returns true on error. */
4851 arg_assoc_class_only (struct arg_lookup
*k
, tree type
)
4853 tree list
, friends
, context
;
4855 /* Backend-built structures, such as __builtin_va_list, aren't
4856 affected by all this. */
4857 if (!CLASS_TYPE_P (type
))
4860 context
= decl_namespace_context (type
);
4861 if (arg_assoc_namespace (k
, context
))
4864 complete_type (type
);
4866 /* Process friends. */
4867 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
4868 list
= TREE_CHAIN (list
))
4869 if (k
->name
== FRIEND_NAME (list
))
4870 for (friends
= FRIEND_DECLS (list
); friends
;
4871 friends
= TREE_CHAIN (friends
))
4873 tree fn
= TREE_VALUE (friends
);
4875 /* Only interested in global functions with potentially hidden
4876 (i.e. unqualified) declarations. */
4877 if (CP_DECL_CONTEXT (fn
) != context
)
4879 /* Template specializations are never found by name lookup.
4880 (Templates themselves can be found, but not template
4881 specializations.) */
4882 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
4884 if (add_function (k
, fn
))
4891 /* Adds the class and its bases to the lookup structure.
4892 Returns true on error. */
4895 arg_assoc_bases (struct arg_lookup
*k
, tree type
)
4897 if (arg_assoc_class_only (k
, type
))
4900 if (TYPE_BINFO (type
))
4902 /* Process baseclasses. */
4903 tree binfo
, base_binfo
;
4906 for (binfo
= TYPE_BINFO (type
), i
= 0;
4907 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4908 if (arg_assoc_bases (k
, BINFO_TYPE (base_binfo
)))
4915 /* Adds everything associated with a class argument type to the lookup
4916 structure. Returns true on error.
4918 If T is a class type (including unions), its associated classes are: the
4919 class itself; the class of which it is a member, if any; and its direct
4920 and indirect base classes. Its associated namespaces are the namespaces
4921 of which its associated classes are members. Furthermore, if T is a
4922 class template specialization, its associated namespaces and classes
4923 also include: the namespaces and classes associated with the types of
4924 the template arguments provided for template type parameters (excluding
4925 template template parameters); the namespaces of which any template
4926 template arguments are members; and the classes of which any member
4927 templates used as template template arguments are members. [ Note:
4928 non-type template arguments do not contribute to the set of associated
4929 namespaces. --end note] */
4932 arg_assoc_class (struct arg_lookup
*k
, tree type
)
4937 /* Backend build structures, such as __builtin_va_list, aren't
4938 affected by all this. */
4939 if (!CLASS_TYPE_P (type
))
4942 if (vec_member (type
, k
->classes
))
4944 VEC_safe_push (tree
, gc
, k
->classes
, type
);
4946 if (TYPE_CLASS_SCOPE_P (type
)
4947 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
4950 if (arg_assoc_bases (k
, type
))
4953 /* Process template arguments. */
4954 if (CLASSTYPE_TEMPLATE_INFO (type
)
4955 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
4957 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
4958 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
4959 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
)))
4966 /* Adds everything associated with a given type.
4967 Returns 1 on error. */
4970 arg_assoc_type (struct arg_lookup
*k
, tree type
)
4972 /* As we do not get the type of non-type dependent expressions
4973 right, we can end up with such things without a type. */
4977 if (TYPE_PTRMEM_P (type
))
4979 /* Pointer to member: associate class type and value type. */
4980 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
4982 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
4984 else switch (TREE_CODE (type
))
4994 case FIXED_POINT_TYPE
:
4999 if (TYPE_PTRMEMFUNC_P (type
))
5000 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
5002 return arg_assoc_class (k
, type
);
5004 case REFERENCE_TYPE
:
5006 return arg_assoc_type (k
, TREE_TYPE (type
));
5008 if (TYPE_CLASS_SCOPE_P (type
)
5009 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5011 return arg_assoc_namespace (k
, decl_namespace_context (type
));
5013 /* The basetype is referenced in the first arg type, so just
5016 /* Associate the parameter types. */
5017 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
5019 /* Associate the return type. */
5020 return arg_assoc_type (k
, TREE_TYPE (type
));
5021 case TEMPLATE_TYPE_PARM
:
5022 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5027 gcc_assert (type
== unknown_type_node
5028 || type
== init_list_type_node
);
5030 case TYPE_PACK_EXPANSION
:
5031 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
5039 /* Adds everything associated with arguments. Returns true on error. */
5042 arg_assoc_args (struct arg_lookup
*k
, tree args
)
5044 for (; args
; args
= TREE_CHAIN (args
))
5045 if (arg_assoc (k
, TREE_VALUE (args
)))
5050 /* Adds everything associated with an argument vector. Returns true
5054 arg_assoc_args_vec (struct arg_lookup
*k
, VEC(tree
,gc
) *args
)
5059 FOR_EACH_VEC_ELT (tree
, args
, ix
, arg
)
5060 if (arg_assoc (k
, arg
))
5065 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5068 arg_assoc (struct arg_lookup
*k
, tree n
)
5070 if (n
== error_mark_node
)
5074 return arg_assoc_type (k
, n
);
5076 if (! type_unknown_p (n
))
5077 return arg_assoc_type (k
, TREE_TYPE (n
));
5079 if (TREE_CODE (n
) == ADDR_EXPR
)
5080 n
= TREE_OPERAND (n
, 0);
5081 if (TREE_CODE (n
) == COMPONENT_REF
)
5082 n
= TREE_OPERAND (n
, 1);
5083 if (TREE_CODE (n
) == OFFSET_REF
)
5084 n
= TREE_OPERAND (n
, 1);
5085 while (TREE_CODE (n
) == TREE_LIST
)
5087 if (TREE_CODE (n
) == BASELINK
)
5088 n
= BASELINK_FUNCTIONS (n
);
5090 if (TREE_CODE (n
) == FUNCTION_DECL
)
5091 return arg_assoc_type (k
, TREE_TYPE (n
));
5092 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
5094 /* The working paper doesn't currently say how to handle template-id
5095 arguments. The sensible thing would seem to be to handle the list
5096 of template candidates like a normal overload set, and handle the
5097 template arguments like we do for class template
5099 tree templ
= TREE_OPERAND (n
, 0);
5100 tree args
= TREE_OPERAND (n
, 1);
5103 /* First the templates. */
5104 if (arg_assoc (k
, templ
))
5107 /* Now the arguments. */
5109 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
5110 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
5113 else if (TREE_CODE (n
) == OVERLOAD
)
5115 for (; n
; n
= OVL_CHAIN (n
))
5116 if (arg_assoc_type (k
, TREE_TYPE (OVL_FUNCTION (n
))))
5123 /* Performs Koenig lookup depending on arguments, where fns
5124 are the functions found in normal lookup. */
5127 lookup_arg_dependent (tree name
, tree fns
, VEC(tree
,gc
) *args
,
5130 struct arg_lookup k
;
5132 timevar_push (TV_NAME_LOOKUP
);
5134 /* Remove any hidden friend functions from the list of functions
5135 found so far. They will be added back by arg_assoc_class as
5137 fns
= remove_hidden_names (fns
);
5142 k
.classes
= make_tree_vector ();
5144 /* We previously performed an optimization here by setting
5145 NAMESPACES to the current namespace when it was safe. However, DR
5146 164 says that namespaces that were already searched in the first
5147 stage of template processing are searched again (potentially
5148 picking up later definitions) in the second stage. */
5149 k
.namespaces
= make_tree_vector ();
5152 arg_assoc_namespace (&k
, std_node
);
5153 arg_assoc_args_vec (&k
, args
);
5158 && TREE_CODE (fns
) != VAR_DECL
5159 && !is_overloaded_fn (fns
))
5161 error ("argument dependent lookup finds %q+D", fns
);
5162 error (" in call to %qD", name
);
5163 fns
= error_mark_node
;
5166 release_tree_vector (k
.classes
);
5167 release_tree_vector (k
.namespaces
);
5169 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, fns
);
5172 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5173 changed (i.e. there was already a directive), or the fresh
5174 TREE_LIST otherwise. */
5177 push_using_directive (tree used
)
5179 tree ud
= current_binding_level
->using_directives
;
5180 tree iter
, ancestor
;
5182 timevar_push (TV_NAME_LOOKUP
);
5183 /* Check if we already have this. */
5184 if (purpose_member (used
, ud
) != NULL_TREE
)
5185 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
5187 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
5188 ud
= current_binding_level
->using_directives
;
5189 ud
= tree_cons (used
, ancestor
, ud
);
5190 current_binding_level
->using_directives
= ud
;
5192 /* Recursively add all namespaces used. */
5193 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
5194 push_using_directive (TREE_PURPOSE (iter
));
5196 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ud
);
5199 /* The type TYPE is being declared. If it is a class template, or a
5200 specialization of a class template, do any processing required and
5201 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5202 being declared a friend. B is the binding level at which this TYPE
5205 Returns the TYPE_DECL for TYPE, which may have been altered by this
5209 maybe_process_template_type_declaration (tree type
, int is_friend
,
5212 tree decl
= TYPE_NAME (type
);
5214 if (processing_template_parmlist
)
5215 /* You can't declare a new template type in a template parameter
5216 list. But, you can declare a non-template type:
5218 template <class A*> struct S;
5220 is a forward-declaration of `A'. */
5222 else if (b
->kind
== sk_namespace
5223 && current_binding_level
->kind
!= sk_namespace
)
5224 /* If this new type is being injected into a containing scope,
5225 then it's not a template type. */
5229 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5230 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5232 if (processing_template_decl
)
5234 /* This may change after the call to
5235 push_template_decl_real, but we want the original value. */
5236 tree name
= DECL_NAME (decl
);
5238 decl
= push_template_decl_real (decl
, is_friend
);
5239 if (decl
== error_mark_node
)
5240 return error_mark_node
;
5242 /* If the current binding level is the binding level for the
5243 template parameters (see the comment in
5244 begin_template_parm_list) and the enclosing level is a class
5245 scope, and we're not looking at a friend, push the
5246 declaration of the member class into the class scope. In the
5247 friend case, push_template_decl will already have put the
5248 friend into global scope, if appropriate. */
5249 if (TREE_CODE (type
) != ENUMERAL_TYPE
5250 && !is_friend
&& b
->kind
== sk_template_parms
5251 && b
->level_chain
->kind
== sk_class
)
5253 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5255 if (!COMPLETE_TYPE_P (current_class_type
))
5257 maybe_add_class_template_decl_list (current_class_type
,
5258 type
, /*friend_p=*/0);
5259 /* Put this UTD in the table of UTDs for the class. */
5260 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5261 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5262 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5264 binding_table_insert
5265 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5274 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5275 that the NAME is a class template, the tag is processed but not pushed.
5277 The pushed scope depend on the SCOPE parameter:
5278 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5280 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5281 non-template-parameter scope. This case is needed for forward
5283 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5284 TS_GLOBAL case except that names within template-parameter scopes
5285 are not pushed at all.
5287 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5290 pushtag (tree name
, tree type
, tag_scope scope
)
5292 struct cp_binding_level
*b
;
5295 timevar_push (TV_NAME_LOOKUP
);
5296 b
= current_binding_level
;
5297 while (/* Cleanup scopes are not scopes from the point of view of
5299 b
->kind
== sk_cleanup
5300 /* Neither are function parameter scopes. */
5301 || b
->kind
== sk_function_parms
5302 /* Neither are the scopes used to hold template parameters
5303 for an explicit specialization. For an ordinary template
5304 declaration, these scopes are not scopes from the point of
5305 view of the language. */
5306 || (b
->kind
== sk_template_parms
5307 && (b
->explicit_spec_p
|| scope
== ts_global
))
5308 || (b
->kind
== sk_class
5309 && (scope
!= ts_current
5310 /* We may be defining a new type in the initializer
5311 of a static member variable. We allow this when
5312 not pedantic, and it is particularly useful for
5313 type punning via an anonymous union. */
5314 || COMPLETE_TYPE_P (b
->this_entity
))))
5317 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5319 /* Do C++ gratuitous typedefing. */
5320 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
5324 tree context
= TYPE_CONTEXT (type
);
5328 tree cs
= current_scope ();
5330 if (scope
== ts_current
5331 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
5333 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5334 /* When declaring a friend class of a local class, we want
5335 to inject the newly named class into the scope
5336 containing the local class, not the namespace
5338 context
= decl_function_context (get_type_decl (cs
));
5341 context
= current_namespace
;
5343 if (b
->kind
== sk_class
5344 || (b
->kind
== sk_template_parms
5345 && b
->level_chain
->kind
== sk_class
))
5348 if (current_lang_name
== lang_name_java
)
5349 TYPE_FOR_JAVA (type
) = 1;
5351 tdef
= create_implicit_typedef (name
, type
);
5352 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5353 if (scope
== ts_within_enclosing_non_class
)
5355 /* This is a friend. Make this TYPE_DECL node hidden from
5356 ordinary name lookup. Its corresponding TEMPLATE_DECL
5357 will be marked in push_template_decl_real. */
5358 retrofit_lang_decl (tdef
);
5359 DECL_ANTICIPATED (tdef
) = 1;
5360 DECL_FRIEND_P (tdef
) = 1;
5363 decl
= maybe_process_template_type_declaration
5364 (type
, scope
== ts_within_enclosing_non_class
, b
);
5365 if (decl
== error_mark_node
)
5366 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
5368 if (b
->kind
== sk_class
)
5370 if (!TYPE_BEING_DEFINED (current_class_type
))
5371 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5373 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5374 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5375 class. But if it's a member template class, we want
5376 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5378 finish_member_declaration (decl
);
5380 pushdecl_class_level (decl
);
5382 else if (b
->kind
!= sk_template_parms
)
5384 decl
= pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
5385 if (decl
== error_mark_node
)
5386 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
5390 set_identifier_type_value_with_scope (name
, tdef
, b
);
5392 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5394 /* If this is a local class, keep track of it. We need this
5395 information for name-mangling, and so that it is possible to
5396 find all function definitions in a translation unit in a
5397 convenient way. (It's otherwise tricky to find a member
5398 function definition it's only pointed to from within a local
5400 if (TYPE_CONTEXT (type
)
5401 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
5402 VEC_safe_push (tree
, gc
, local_classes
, type
);
5404 if (b
->kind
== sk_class
5405 && !COMPLETE_TYPE_P (current_class_type
))
5407 maybe_add_class_template_decl_list (current_class_type
,
5408 type
, /*friend_p=*/0);
5410 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5411 CLASSTYPE_NESTED_UTDS (current_class_type
)
5412 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5414 binding_table_insert
5415 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5418 decl
= TYPE_NAME (type
);
5419 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
5421 /* Set type visibility now if this is a forward declaration. */
5422 TREE_PUBLIC (decl
) = 1;
5423 determine_visibility (decl
);
5425 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, type
);
5428 /* Subroutines for reverting temporarily to top-level for instantiation
5429 of templates and such. We actually need to clear out the class- and
5430 local-value slots of all identifiers, so that only the global values
5431 are at all visible. Simply setting current_binding_level to the global
5432 scope isn't enough, because more binding levels may be pushed. */
5433 struct saved_scope
*scope_chain
;
5435 /* If ID has not already been marked, add an appropriate binding to
5439 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5441 cxx_saved_binding
*saved
;
5443 if (!id
|| !IDENTIFIER_BINDING (id
))
5446 if (IDENTIFIER_MARKED (id
))
5449 IDENTIFIER_MARKED (id
) = 1;
5451 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
5452 saved
->identifier
= id
;
5453 saved
->binding
= IDENTIFIER_BINDING (id
);
5454 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
5455 IDENTIFIER_BINDING (id
) = NULL
;
5459 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5463 timevar_push (TV_NAME_LOOKUP
);
5464 for (t
= names
; t
; t
= TREE_CHAIN (t
))
5468 if (TREE_CODE (t
) == TREE_LIST
)
5469 id
= TREE_PURPOSE (t
);
5473 store_binding (id
, old_bindings
);
5475 timevar_pop (TV_NAME_LOOKUP
);
5478 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5479 objects, rather than a TREE_LIST. */
5482 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
5483 VEC(cxx_saved_binding
,gc
) **old_bindings
)
5486 cp_class_binding
*cb
;
5488 timevar_push (TV_NAME_LOOKUP
);
5489 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
5490 store_binding (cb
->identifier
, old_bindings
);
5491 timevar_pop (TV_NAME_LOOKUP
);
5495 push_to_top_level (void)
5497 struct saved_scope
*s
;
5498 struct cp_binding_level
*b
;
5499 cxx_saved_binding
*sb
;
5503 timevar_push (TV_NAME_LOOKUP
);
5504 s
= ggc_alloc_cleared_saved_scope ();
5506 b
= scope_chain
? current_binding_level
: 0;
5508 /* If we're in the middle of some function, save our state. */
5512 push_function_context ();
5517 if (scope_chain
&& previous_class_level
)
5518 store_class_bindings (previous_class_level
->class_shadowed
,
5521 /* Have to include the global scope, because class-scope decls
5522 aren't listed anywhere useful. */
5523 for (; b
; b
= b
->level_chain
)
5527 /* Template IDs are inserted into the global level. If they were
5528 inserted into namespace level, finish_file wouldn't find them
5529 when doing pending instantiations. Therefore, don't stop at
5530 namespace level, but continue until :: . */
5531 if (global_scope_p (b
))
5534 store_bindings (b
->names
, &s
->old_bindings
);
5535 /* We also need to check class_shadowed to save class-level type
5536 bindings, since pushclass doesn't fill in b->names. */
5537 if (b
->kind
== sk_class
)
5538 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
5540 /* Unwind type-value slots back to top level. */
5541 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
5542 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
5545 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, sb
)
5546 IDENTIFIER_MARKED (sb
->identifier
) = 0;
5548 s
->prev
= scope_chain
;
5550 s
->need_pop_function_context
= need_pop
;
5551 s
->function_decl
= current_function_decl
;
5552 s
->unevaluated_operand
= cp_unevaluated_operand
;
5553 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
5556 current_function_decl
= NULL_TREE
;
5557 current_lang_base
= VEC_alloc (tree
, gc
, 10);
5558 current_lang_name
= lang_name_cplusplus
;
5559 current_namespace
= global_namespace
;
5560 push_class_stack ();
5561 cp_unevaluated_operand
= 0;
5562 c_inhibit_evaluation_warnings
= 0;
5563 timevar_pop (TV_NAME_LOOKUP
);
5567 pop_from_top_level (void)
5569 struct saved_scope
*s
= scope_chain
;
5570 cxx_saved_binding
*saved
;
5573 timevar_push (TV_NAME_LOOKUP
);
5574 /* Clear out class-level bindings cache. */
5575 if (previous_class_level
)
5576 invalidate_class_lookup_cache ();
5579 current_lang_base
= 0;
5581 scope_chain
= s
->prev
;
5582 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, saved
)
5584 tree id
= saved
->identifier
;
5586 IDENTIFIER_BINDING (id
) = saved
->binding
;
5587 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
5590 /* If we were in the middle of compiling a function, restore our
5592 if (s
->need_pop_function_context
)
5593 pop_function_context ();
5594 current_function_decl
= s
->function_decl
;
5595 cp_unevaluated_operand
= s
->unevaluated_operand
;
5596 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
5597 timevar_pop (TV_NAME_LOOKUP
);
5600 /* Pop off extraneous binding levels left over due to syntax errors.
5602 We don't pop past namespaces, as they might be valid. */
5605 pop_everything (void)
5607 if (ENABLE_SCOPE_CHECKING
)
5608 verbatim ("XXX entering pop_everything ()\n");
5609 while (!toplevel_bindings_p ())
5611 if (current_binding_level
->kind
== sk_class
)
5612 pop_nested_class ();
5616 if (ENABLE_SCOPE_CHECKING
)
5617 verbatim ("XXX leaving pop_everything ()\n");
5620 /* Emit debugging information for using declarations and directives.
5621 If input tree is overloaded fn then emit debug info for all
5625 cp_emit_debug_info_for_using (tree t
, tree context
)
5627 /* Don't try to emit any debug information if we have errors. */
5631 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5632 of a builtin function. */
5633 if (TREE_CODE (t
) == FUNCTION_DECL
5634 && DECL_EXTERNAL (t
)
5635 && DECL_BUILT_IN (t
))
5638 /* Do not supply context to imported_module_or_decl, if
5639 it is a global namespace. */
5640 if (context
== global_namespace
)
5641 context
= NULL_TREE
;
5644 t
= BASELINK_FUNCTIONS (t
);
5646 /* FIXME: Handle TEMPLATE_DECLs. */
5647 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
5648 if (TREE_CODE (t
) != TEMPLATE_DECL
)
5650 if (building_stmt_tree ())
5651 add_stmt (build_stmt (input_location
, USING_STMT
, t
));
5653 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
5657 #include "gt-cp-name-lookup.h"