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_1 (cxx_binding
*binding
, tree decl
)
439 tree bval
= binding
->value
;
442 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
443 /* The new name is the type name. */
444 binding
->type
= decl
;
445 else if (/* BVAL is null when push_class_level_binding moves an
446 inherited type-binding out of the way to make room for a
447 new value binding. */
449 /* BVAL is error_mark_node when DECL's name has been used
450 in a non-class scope prior declaration. In that case,
451 we should have already issued a diagnostic; for graceful
452 error recovery purpose, pretend this was the intended
453 declaration for that name. */
454 || bval
== error_mark_node
455 /* If BVAL is anticipated but has not yet been declared,
456 pretend it is not there at all. */
457 || (TREE_CODE (bval
) == FUNCTION_DECL
458 && DECL_ANTICIPATED (bval
)
459 && !DECL_HIDDEN_FRIEND_P (bval
)))
460 binding
->value
= decl
;
461 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
463 /* The old binding was a type name. It was placed in
464 VALUE field because it was thought, at the point it was
465 declared, to be the only entity with such a name. Move the
466 type name into the type slot; it is now hidden by the new
468 binding
->type
= bval
;
469 binding
->value
= decl
;
470 binding
->value_is_inherited
= false;
472 else if (TREE_CODE (bval
) == TYPE_DECL
473 && TREE_CODE (decl
) == TYPE_DECL
474 && DECL_NAME (decl
) == DECL_NAME (bval
)
475 && binding
->scope
->kind
!= sk_class
476 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
477 /* If either type involves template parameters, we must
478 wait until instantiation. */
479 || uses_template_parms (TREE_TYPE (decl
))
480 || uses_template_parms (TREE_TYPE (bval
))))
481 /* We have two typedef-names, both naming the same type to have
482 the same name. In general, this is OK because of:
486 In a given scope, a typedef specifier can be used to redefine
487 the name of any type declared in that scope to refer to the
488 type to which it already refers.
490 However, in class scopes, this rule does not apply due to the
491 stricter language in [class.mem] prohibiting redeclarations of
494 /* There can be two block-scope declarations of the same variable,
495 so long as they are `extern' declarations. However, there cannot
496 be two declarations of the same static data member:
500 A member shall not be declared twice in the
501 member-specification. */
502 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
503 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
504 && !DECL_CLASS_SCOPE_P (decl
))
506 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
509 else if (TREE_CODE (decl
) == NAMESPACE_DECL
510 && TREE_CODE (bval
) == NAMESPACE_DECL
511 && DECL_NAMESPACE_ALIAS (decl
)
512 && DECL_NAMESPACE_ALIAS (bval
)
513 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
516 In a declarative region, a namespace-alias-definition can be
517 used to redefine a namespace-alias declared in that declarative
518 region to refer only to the namespace to which it already
523 error ("declaration of %q#D", decl
);
524 error ("conflicts with previous declaration %q+#D", bval
);
531 /* Wrapper for supplement_binding_1. */
534 supplement_binding (cxx_binding
*binding
, tree decl
)
537 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
538 ret
= supplement_binding_1 (binding
, decl
);
539 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
543 /* Add DECL to the list of things declared in B. */
546 add_decl_to_level (tree decl
, cxx_scope
*b
)
548 /* We used to record virtual tables as if they were ordinary
549 variables, but no longer do so. */
550 gcc_assert (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
)));
552 if (TREE_CODE (decl
) == NAMESPACE_DECL
553 && !DECL_NAMESPACE_ALIAS (decl
))
555 DECL_CHAIN (decl
) = b
->namespaces
;
556 b
->namespaces
= decl
;
560 /* We build up the list in reverse order, and reverse it later if
562 TREE_CHAIN (decl
) = b
->names
;
566 /* If appropriate, add decl to separate list of statics. We
567 include extern variables because they might turn out to be
568 static later. It's OK for this list to contain a few false
570 if (b
->kind
== sk_namespace
)
571 if ((TREE_CODE (decl
) == VAR_DECL
572 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
573 || (TREE_CODE (decl
) == FUNCTION_DECL
574 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
575 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
579 /* Record a decl-node X as belonging to the current lexical scope.
580 Check for errors (such as an incompatible declaration for the same
581 name already seen in the same scope). IS_FRIEND is true if X is
582 declared as a friend.
584 Returns either X or an old decl for the same name.
585 If an old decl is returned, it may have been smashed
586 to agree with what X says. */
589 pushdecl_maybe_friend_1 (tree x
, bool is_friend
)
593 int need_new_binding
;
595 if (x
== error_mark_node
)
596 return error_mark_node
;
598 need_new_binding
= 1;
600 if (DECL_TEMPLATE_PARM_P (x
))
601 /* Template parameters have no context; they are not X::T even
602 when declared within a class or namespace. */
606 if (current_function_decl
&& x
!= current_function_decl
607 /* A local declaration for a function doesn't constitute
609 && TREE_CODE (x
) != FUNCTION_DECL
610 /* A local declaration for an `extern' variable is in the
611 scope of the current namespace, not the current
613 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
614 /* When parsing the parameter list of a function declarator,
615 don't set DECL_CONTEXT to an enclosing function. When we
616 push the PARM_DECLs in order to process the function body,
617 current_binding_level->this_entity will be set. */
618 && !(TREE_CODE (x
) == PARM_DECL
619 && current_binding_level
->kind
== sk_function_parms
620 && current_binding_level
->this_entity
== NULL
)
621 && !DECL_CONTEXT (x
))
622 DECL_CONTEXT (x
) = current_function_decl
;
624 /* If this is the declaration for a namespace-scope function,
625 but the declaration itself is in a local scope, mark the
627 if (TREE_CODE (x
) == FUNCTION_DECL
628 && DECL_NAMESPACE_SCOPE_P (x
)
629 && current_function_decl
630 && x
!= current_function_decl
)
631 DECL_LOCAL_FUNCTION_P (x
) = 1;
634 name
= DECL_NAME (x
);
637 int different_binding_level
= 0;
639 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
640 name
= TREE_OPERAND (name
, 0);
642 /* In case this decl was explicitly namespace-qualified, look it
643 up in its namespace context. */
644 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
645 t
= namespace_binding (name
, DECL_CONTEXT (x
));
647 t
= lookup_name_innermost_nonclass_level (name
);
649 /* [basic.link] If there is a visible declaration of an entity
650 with linkage having the same name and type, ignoring entities
651 declared outside the innermost enclosing namespace scope, the
652 block scope declaration declares that same entity and
653 receives the linkage of the previous declaration. */
654 if (! t
&& current_function_decl
&& x
!= current_function_decl
655 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
656 && DECL_EXTERNAL (x
))
658 /* Look in block scope. */
659 t
= innermost_non_namespace_value (name
);
660 /* Or in the innermost namespace. */
662 t
= namespace_binding (name
, DECL_CONTEXT (x
));
663 /* Does it have linkage? Note that if this isn't a DECL, it's an
664 OVERLOAD, which is OK. */
665 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
668 different_binding_level
= 1;
671 /* If we are declaring a function, and the result of name-lookup
672 was an OVERLOAD, look for an overloaded instance that is
673 actually the same as the function we are declaring. (If
674 there is one, we have to merge our declaration with the
675 previous declaration.) */
676 if (t
&& TREE_CODE (t
) == OVERLOAD
)
680 if (TREE_CODE (x
) == FUNCTION_DECL
)
681 for (match
= t
; match
; match
= OVL_NEXT (match
))
683 if (decls_match (OVL_CURRENT (match
), x
))
687 /* Just choose one. */
691 t
= OVL_CURRENT (match
);
696 if (t
&& t
!= error_mark_node
)
698 if (different_binding_level
)
700 if (decls_match (x
, t
))
701 /* The standard only says that the local extern
702 inherits linkage from the previous decl; in
703 particular, default args are not shared. Add
704 the decl into a hash table to make sure only
705 the previous decl in this case is seen by the
708 struct cxx_int_tree_map
*h
;
711 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
713 if (cp_function_chain
->extern_decl_map
== NULL
)
714 cp_function_chain
->extern_decl_map
715 = htab_create_ggc (20, cxx_int_tree_map_hash
,
716 cxx_int_tree_map_eq
, NULL
);
718 h
= ggc_alloc_cxx_int_tree_map ();
719 h
->uid
= DECL_UID (x
);
721 loc
= htab_find_slot_with_hash
722 (cp_function_chain
->extern_decl_map
, h
,
724 *(struct cxx_int_tree_map
**) loc
= h
;
727 else if (TREE_CODE (t
) == PARM_DECL
)
729 /* Check for duplicate params. */
730 tree d
= duplicate_decls (x
, t
, is_friend
);
734 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
735 || DECL_FUNCTION_TEMPLATE_P (x
))
736 && is_overloaded_fn (t
))
737 /* Don't do anything just yet. */;
738 else if (t
== wchar_decl_node
)
740 if (! DECL_IN_SYSTEM_HEADER (x
))
741 pedwarn (input_location
, OPT_pedantic
, "redeclaration of %<wchar_t%> as %qT",
744 /* Throw away the redeclaration. */
749 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
751 /* If the redeclaration failed, we can stop at this
753 if (olddecl
== error_mark_node
)
754 return error_mark_node
;
758 if (TREE_CODE (t
) == TYPE_DECL
)
759 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
763 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
765 /* A redeclaration of main, but not a duplicate of the
770 This function shall not be overloaded. */
771 error ("invalid redeclaration of %q+D", t
);
773 /* We don't try to push this declaration since that
780 /* If x has C linkage-specification, (extern "C"),
781 lookup its binding, in case it's already bound to an object.
782 The lookup is done in all namespaces.
783 If we find an existing binding, make sure it has the same
784 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
785 if ((TREE_CODE (x
) == FUNCTION_DECL
)
786 && DECL_EXTERN_C_P (x
)
787 /* We should ignore declarations happening in system headers. */
788 && !DECL_ARTIFICIAL (x
)
789 && !DECL_IN_SYSTEM_HEADER (x
))
791 cxx_binding
*function_binding
=
792 lookup_extern_c_fun_binding_in_all_ns (x
);
793 tree previous
= (function_binding
794 ? function_binding
->value
797 && !DECL_ARTIFICIAL (previous
)
798 && !DECL_IN_SYSTEM_HEADER (previous
)
799 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
801 tree previous
= function_binding
->value
;
803 /* In case either x or previous is declared to throw an exception,
804 make sure both exception specifications are equal. */
805 if (decls_match (x
, previous
))
807 tree x_exception_spec
= NULL_TREE
;
808 tree previous_exception_spec
= NULL_TREE
;
811 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
812 previous_exception_spec
=
813 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
814 if (!comp_except_specs (previous_exception_spec
,
818 pedwarn (input_location
, 0,
819 "declaration of %q#D with C language linkage",
821 pedwarn (input_location
, 0,
822 "conflicts with previous declaration %q+#D",
824 pedwarn (input_location
, 0,
825 "due to different exception specifications");
826 return error_mark_node
;
831 pedwarn (input_location
, 0,
832 "declaration of %q#D with C language linkage", x
);
833 pedwarn (input_location
, 0,
834 "conflicts with previous declaration %q+#D",
840 check_template_shadow (x
);
842 /* If this is a function conjured up by the back end, massage it
843 so it looks friendly. */
844 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
846 retrofit_lang_decl (x
);
847 SET_DECL_LANGUAGE (x
, lang_c
);
851 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
853 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
854 if (!namespace_bindings_p ())
855 /* We do not need to create a binding for this name;
856 push_overloaded_decl will have already done so if
858 need_new_binding
= 0;
860 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
862 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
864 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
867 if (TREE_CODE (t
) == FUNCTION_DECL
|| DECL_FUNCTION_TEMPLATE_P (t
))
868 check_default_args (t
);
870 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
873 /* If declaring a type as a typedef, copy the type (unless we're
874 at line 0), and install this TYPE_DECL as the new type's typedef
875 name. See the extensive comment of set_underlying_type (). */
876 if (TREE_CODE (x
) == TYPE_DECL
)
878 tree type
= TREE_TYPE (x
);
880 if (DECL_IS_BUILTIN (x
)
881 || (TREE_TYPE (x
) != error_mark_node
882 && TYPE_NAME (type
) != x
883 /* We don't want to copy the type when all we're
884 doing is making a TYPE_DECL for the purposes of
886 && (!TYPE_NAME (type
)
887 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
888 set_underlying_type (x
);
890 if (type
!= error_mark_node
892 && TYPE_IDENTIFIER (type
))
893 set_identifier_type_value (DECL_NAME (x
), x
);
896 /* Multiple external decls of the same identifier ought to match.
898 We get warnings about inline functions where they are defined.
899 We get warnings about other functions from push_overloaded_decl.
901 Avoid duplicate warnings where they are used. */
902 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
906 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
907 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
908 decl
= OVL_FUNCTION (decl
);
910 if (decl
&& decl
!= error_mark_node
911 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
912 /* If different sort of thing, we already gave an error. */
913 && TREE_CODE (decl
) == TREE_CODE (x
)
914 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
916 permerror (input_location
, "type mismatch with previous external decl of %q#D", x
);
917 permerror (input_location
, "previous external decl of %q+#D", decl
);
921 if (TREE_CODE (x
) == FUNCTION_DECL
923 && !flag_friend_injection
)
925 /* This is a new declaration of a friend function, so hide
926 it from ordinary function lookup. */
927 DECL_ANTICIPATED (x
) = 1;
928 DECL_HIDDEN_FRIEND_P (x
) = 1;
931 /* This name is new in its binding level.
932 Install the new declaration and return it. */
933 if (namespace_bindings_p ())
935 /* Install a global value. */
937 /* If the first global decl has external linkage,
938 warn if we later see static one. */
939 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
940 TREE_PUBLIC (name
) = 1;
942 /* Bind the name for the entity. */
943 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
945 && (TREE_CODE (x
) == TYPE_DECL
946 || TREE_CODE (x
) == VAR_DECL
947 || TREE_CODE (x
) == NAMESPACE_DECL
948 || TREE_CODE (x
) == CONST_DECL
949 || TREE_CODE (x
) == TEMPLATE_DECL
))
950 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
952 /* If new decl is `static' and an `extern' was seen previously,
954 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
955 warn_extern_redeclared_static (x
, t
);
959 /* Here to install a non-global value. */
960 tree oldlocal
= innermost_non_namespace_value (name
);
961 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
963 if (need_new_binding
)
965 push_local_binding (name
, x
, 0);
966 /* Because push_local_binding will hook X on to the
967 current_binding_level's name list, we don't want to
968 do that again below. */
969 need_new_binding
= 0;
972 /* If this is a TYPE_DECL, push it into the type value slot. */
973 if (TREE_CODE (x
) == TYPE_DECL
)
974 set_identifier_type_value (name
, x
);
976 /* Clear out any TYPE_DECL shadowed by a namespace so that
977 we won't think this is a type. The C struct hack doesn't
978 go through namespaces. */
979 if (TREE_CODE (x
) == NAMESPACE_DECL
)
980 set_identifier_type_value (name
, NULL_TREE
);
987 && TREE_CODE (oldlocal
) == VAR_DECL
988 && DECL_DEAD_FOR_LOCAL (oldlocal
))
989 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
991 if (oldlocal
== NULL_TREE
)
992 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
995 /* If this is an extern function declaration, see if we
996 have a global definition or declaration for the function. */
997 if (oldlocal
== NULL_TREE
999 && oldglobal
!= NULL_TREE
1000 && TREE_CODE (x
) == FUNCTION_DECL
1001 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
1003 /* We have one. Their types must agree. */
1004 if (decls_match (x
, oldglobal
))
1008 warning (0, "extern declaration of %q#D doesn%'t match", x
);
1009 warning (0, "global declaration %q+#D", oldglobal
);
1012 /* If we have a local external declaration,
1013 and no file-scope declaration has yet been seen,
1014 then if we later have a file-scope decl it must not be static. */
1015 if (oldlocal
== NULL_TREE
1016 && oldglobal
== NULL_TREE
1017 && DECL_EXTERNAL (x
)
1019 TREE_PUBLIC (name
) = 1;
1021 /* Don't complain about the parms we push and then pop
1022 while tentatively parsing a function declarator. */
1023 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1026 /* Warn if shadowing an argument at the top level of the body. */
1027 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1028 /* Inline decls shadow nothing. */
1029 && !DECL_FROM_INLINE (x
)
1030 && (TREE_CODE (oldlocal
) == PARM_DECL
1031 || TREE_CODE (oldlocal
) == VAR_DECL
1032 /* If the old decl is a type decl, only warn if the
1033 old decl is an explicit typedef or if both the old
1034 and new decls are type decls. */
1035 || (TREE_CODE (oldlocal
) == TYPE_DECL
1036 && (!DECL_ARTIFICIAL (oldlocal
)
1037 || TREE_CODE (x
) == TYPE_DECL
)))
1038 /* Don't check the `this' parameter or internally generated
1039 vars unless it's an implicit typedef (see
1040 create_implicit_typedef in decl.c). */
1041 && (!DECL_ARTIFICIAL (oldlocal
)
1042 || DECL_IMPLICIT_TYPEDEF_P (oldlocal
))
1043 /* Don't check for internally generated vars unless
1044 it's an implicit typedef (see create_implicit_typedef
1046 && (!DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
)))
1048 bool nowarn
= false;
1050 /* Don't complain if it's from an enclosing function. */
1051 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1052 && TREE_CODE (x
) != PARM_DECL
1053 && TREE_CODE (oldlocal
) == PARM_DECL
)
1055 /* Go to where the parms should be and see if we find
1057 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
1059 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1060 /* Skip the ctor/dtor cleanup level. */
1064 if (b
->kind
== sk_function_parms
)
1066 error ("declaration of %q#D shadows a parameter", x
);
1071 /* The local structure or class can't use parameters of
1072 the containing function anyway. */
1073 if (DECL_CONTEXT (oldlocal
) != current_function_decl
)
1075 cxx_scope
*scope
= current_binding_level
;
1076 tree context
= DECL_CONTEXT (oldlocal
);
1077 for (; scope
; scope
= scope
->level_chain
)
1079 if (scope
->kind
== sk_function_parms
1080 && scope
->this_entity
== context
)
1082 if (scope
->kind
== sk_class
1083 && !LAMBDA_TYPE_P (scope
->this_entity
))
1091 if (warn_shadow
&& !nowarn
)
1093 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1094 warning_at (input_location
, OPT_Wshadow
,
1095 "declaration of %q#D shadows a parameter", x
);
1097 warning_at (input_location
, OPT_Wshadow
,
1098 "declaration of %qD shadows a previous local",
1100 warning_at (DECL_SOURCE_LOCATION (oldlocal
), OPT_Wshadow
,
1101 "shadowed declaration is here");
1105 /* Maybe warn if shadowing something else. */
1106 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1107 /* No shadow warnings for internally generated vars unless
1108 it's an implicit typedef (see create_implicit_typedef
1110 && (! DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
))
1111 /* No shadow warnings for vars made for inlining. */
1112 && ! DECL_FROM_INLINE (x
))
1116 if (current_class_ptr
)
1117 member
= lookup_member (current_class_type
,
1120 /*want_type=*/false);
1124 if (member
&& !TREE_STATIC (member
))
1126 /* Location of previous decl is not useful in this case. */
1127 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
1130 else if (oldglobal
!= NULL_TREE
1131 && (TREE_CODE (oldglobal
) == VAR_DECL
1132 /* If the old decl is a type decl, only warn if the
1133 old decl is an explicit typedef or if both the
1134 old and new decls are type decls. */
1135 || (TREE_CODE (oldglobal
) == TYPE_DECL
1136 && (!DECL_ARTIFICIAL (oldglobal
)
1137 || TREE_CODE (x
) == TYPE_DECL
))))
1138 /* XXX shadow warnings in outer-more namespaces */
1140 warning_at (input_location
, OPT_Wshadow
,
1141 "declaration of %qD shadows a global declaration", x
);
1142 warning_at (DECL_SOURCE_LOCATION (oldglobal
), OPT_Wshadow
,
1143 "shadowed declaration is here");
1148 if (TREE_CODE (x
) == VAR_DECL
)
1149 maybe_register_incomplete_var (x
);
1152 if (need_new_binding
)
1153 add_decl_to_level (x
,
1154 DECL_NAMESPACE_SCOPE_P (x
)
1155 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1156 : current_binding_level
);
1161 /* Wrapper for pushdecl_maybe_friend_1. */
1164 pushdecl_maybe_friend (tree x
, bool is_friend
)
1167 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1168 ret
= pushdecl_maybe_friend_1 (x
, is_friend
);
1169 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1173 /* Record a decl-node X as belonging to the current lexical scope. */
1178 return pushdecl_maybe_friend (x
, false);
1181 /* Enter DECL into the symbol table, if that's appropriate. Returns
1182 DECL, or a modified version thereof. */
1185 maybe_push_decl (tree decl
)
1187 tree type
= TREE_TYPE (decl
);
1189 /* Add this decl to the current binding level, but not if it comes
1190 from another scope, e.g. a static member variable. TEM may equal
1191 DECL or it may be a previous decl of the same name. */
1192 if (decl
== error_mark_node
1193 || (TREE_CODE (decl
) != PARM_DECL
1194 && DECL_CONTEXT (decl
) != NULL_TREE
1195 /* Definitions of namespace members outside their namespace are
1197 && !DECL_NAMESPACE_SCOPE_P (decl
))
1198 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1199 || type
== unknown_type_node
1200 /* The declaration of a template specialization does not affect
1201 the functions available for overload resolution, so we do not
1203 || (TREE_CODE (decl
) == FUNCTION_DECL
1204 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1207 return pushdecl (decl
);
1210 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1211 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1212 doesn't really belong to this binding level, that it got here
1213 through a using-declaration. */
1216 push_local_binding (tree id
, tree decl
, int flags
)
1218 struct cp_binding_level
*b
;
1220 /* Skip over any local classes. This makes sense if we call
1221 push_local_binding with a friend decl of a local class. */
1222 b
= innermost_nonclass_level ();
1224 if (lookup_name_innermost_nonclass_level (id
))
1226 /* Supplement the existing binding. */
1227 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1228 /* It didn't work. Something else must be bound at this
1229 level. Do not add DECL to the list of things to pop
1234 /* Create a new binding. */
1235 push_binding (id
, decl
, b
);
1237 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1238 /* We must put the OVERLOAD into a TREE_LIST since the
1239 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1240 decls that got here through a using-declaration. */
1241 decl
= build_tree_list (NULL_TREE
, decl
);
1243 /* And put DECL on the list of things declared by the current
1245 add_decl_to_level (decl
, b
);
1248 /* Check to see whether or not DECL is a variable that would have been
1249 in scope under the ARM, but is not in scope under the ANSI/ISO
1250 standard. If so, issue an error message. If name lookup would
1251 work in both cases, but return a different result, this function
1252 returns the result of ANSI/ISO lookup. Otherwise, it returns
1256 check_for_out_of_scope_variable (tree decl
)
1260 /* We only care about out of scope variables. */
1261 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1264 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1265 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1266 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1267 && DECL_DEAD_FOR_LOCAL (shadowed
))
1268 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1269 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1271 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1274 if (!DECL_ERROR_REPORTED (decl
))
1276 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1277 warning (0, " matches this %q+D under ISO standard rules",
1279 warning (0, " matches this %q+D under old rules", decl
);
1280 DECL_ERROR_REPORTED (decl
) = 1;
1285 /* If we have already complained about this declaration, there's no
1286 need to do it again. */
1287 if (DECL_ERROR_REPORTED (decl
))
1290 DECL_ERROR_REPORTED (decl
) = 1;
1292 if (TREE_TYPE (decl
) == error_mark_node
)
1295 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1297 error ("name lookup of %qD changed for ISO %<for%> scoping",
1299 error (" cannot use obsolete binding at %q+D because "
1300 "it has a destructor", decl
);
1301 return error_mark_node
;
1305 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1307 if (flag_permissive
)
1308 permerror (input_location
, " using obsolete binding at %q+D", decl
);
1314 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1323 /* true means unconditionally make a BLOCK for the next level pushed. */
1325 static bool keep_next_level_flag
;
1327 static int binding_depth
= 0;
1334 for (i
= 0; i
< depth
* 2; i
++)
1338 /* Return a string describing the kind of SCOPE we have. */
1340 cxx_scope_descriptor (cxx_scope
*scope
)
1342 /* The order of this table must match the "scope_kind"
1344 static const char* scope_kind_names
[] = {
1350 "function-parameter-scope",
1353 "template-parameter-scope",
1354 "template-explicit-spec-scope"
1356 const scope_kind kind
= scope
->explicit_spec_p
1357 ? sk_template_spec
: scope
->kind
;
1359 return scope_kind_names
[kind
];
1362 /* Output a debugging information about SCOPE when performing
1365 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1367 const char *desc
= cxx_scope_descriptor (scope
);
1368 if (scope
->this_entity
)
1369 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1370 scope
->this_entity
, (void *) scope
, line
);
1372 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1375 /* Return the estimated initial size of the hashtable of a NAMESPACE
1378 static inline size_t
1379 namespace_scope_ht_size (tree ns
)
1381 tree name
= DECL_NAME (ns
);
1383 return name
== std_identifier
1384 ? NAMESPACE_STD_HT_SIZE
1385 : (name
== global_scope_name
1386 ? GLOBAL_SCOPE_HT_SIZE
1387 : NAMESPACE_ORDINARY_HT_SIZE
);
1390 /* A chain of binding_level structures awaiting reuse. */
1392 static GTY((deletable
)) struct cp_binding_level
*free_binding_level
;
1394 /* Insert SCOPE as the innermost binding level. */
1397 push_binding_level (struct cp_binding_level
*scope
)
1399 /* Add it to the front of currently active scopes stack. */
1400 scope
->level_chain
= current_binding_level
;
1401 current_binding_level
= scope
;
1402 keep_next_level_flag
= false;
1404 if (ENABLE_SCOPE_CHECKING
)
1406 scope
->binding_depth
= binding_depth
;
1407 indent (binding_depth
);
1408 cxx_scope_debug (scope
, input_line
, "push");
1413 /* Create a new KIND scope and make it the top of the active scopes stack.
1414 ENTITY is the scope of the associated C++ entity (namespace, class,
1415 function, C++0x enumeration); it is NULL otherwise. */
1418 begin_scope (scope_kind kind
, tree entity
)
1422 /* Reuse or create a struct for this binding level. */
1423 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1425 scope
= free_binding_level
;
1426 memset (scope
, 0, sizeof (cxx_scope
));
1427 free_binding_level
= scope
->level_chain
;
1430 scope
= ggc_alloc_cleared_cxx_scope ();
1432 scope
->this_entity
= entity
;
1433 scope
->more_cleanups_ok
= true;
1440 case sk_template_spec
:
1441 scope
->explicit_spec_p
= true;
1442 kind
= sk_template_parms
;
1444 case sk_template_parms
:
1450 case sk_scoped_enum
:
1451 case sk_function_parms
:
1453 scope
->keep
= keep_next_level_flag
;
1457 NAMESPACE_LEVEL (entity
) = scope
;
1458 scope
->static_decls
=
1459 VEC_alloc (tree
, gc
,
1460 DECL_NAME (entity
) == std_identifier
1461 || DECL_NAME (entity
) == global_scope_name
1466 /* Should not happen. */
1472 push_binding_level (scope
);
1477 /* We're about to leave current scope. Pop the top of the stack of
1478 currently active scopes. Return the enclosing scope, now active. */
1483 cxx_scope
*scope
= current_binding_level
;
1485 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1486 current_binding_level
= class_binding_level
;
1488 /* We cannot leave a scope, if there are none left. */
1489 if (NAMESPACE_LEVEL (global_namespace
))
1490 gcc_assert (!global_scope_p (scope
));
1492 if (ENABLE_SCOPE_CHECKING
)
1494 indent (--binding_depth
);
1495 cxx_scope_debug (scope
, input_line
, "leave");
1498 /* Move one nesting level up. */
1499 current_binding_level
= scope
->level_chain
;
1501 /* Namespace-scopes are left most probably temporarily, not
1502 completely; they can be reopened later, e.g. in namespace-extension
1503 or any name binding activity that requires us to resume a
1504 namespace. For classes, we cache some binding levels. For other
1505 scopes, we just make the structure available for reuse. */
1506 if (scope
->kind
!= sk_namespace
1507 && scope
->kind
!= sk_class
)
1509 scope
->level_chain
= free_binding_level
;
1510 gcc_assert (!ENABLE_SCOPE_CHECKING
1511 || scope
->binding_depth
== binding_depth
);
1512 free_binding_level
= scope
;
1515 /* Find the innermost enclosing class scope, and reset
1516 CLASS_BINDING_LEVEL appropriately. */
1517 if (scope
->kind
== sk_class
)
1519 class_binding_level
= NULL
;
1520 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1521 if (scope
->kind
== sk_class
)
1523 class_binding_level
= scope
;
1528 return current_binding_level
;
1532 resume_scope (struct cp_binding_level
* b
)
1534 /* Resuming binding levels is meant only for namespaces,
1535 and those cannot nest into classes. */
1536 gcc_assert (!class_binding_level
);
1537 /* Also, resuming a non-directly nested namespace is a no-no. */
1538 gcc_assert (b
->level_chain
== current_binding_level
);
1539 current_binding_level
= b
;
1540 if (ENABLE_SCOPE_CHECKING
)
1542 b
->binding_depth
= binding_depth
;
1543 indent (binding_depth
);
1544 cxx_scope_debug (b
, input_line
, "resume");
1549 /* Return the innermost binding level that is not for a class scope. */
1552 innermost_nonclass_level (void)
1556 b
= current_binding_level
;
1557 while (b
->kind
== sk_class
)
1563 /* We're defining an object of type TYPE. If it needs a cleanup, but
1564 we're not allowed to add any more objects with cleanups to the current
1565 scope, create a new binding level. */
1568 maybe_push_cleanup_level (tree type
)
1570 if (type
!= error_mark_node
1571 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1572 && current_binding_level
->more_cleanups_ok
== 0)
1574 begin_scope (sk_cleanup
, NULL
);
1575 current_binding_level
->statement_list
= push_stmt_list ();
1579 /* Nonzero if we are currently in the global binding level. */
1582 global_bindings_p (void)
1584 return global_scope_p (current_binding_level
);
1587 /* True if we are currently in a toplevel binding level. This
1588 means either the global binding level or a namespace in a toplevel
1589 binding level. Since there are no non-toplevel namespace levels,
1590 this really means any namespace or template parameter level. We
1591 also include a class whose context is toplevel. */
1594 toplevel_bindings_p (void)
1596 struct cp_binding_level
*b
= innermost_nonclass_level ();
1598 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1601 /* True if this is a namespace scope, or if we are defining a class
1602 which is itself at namespace scope, or whose enclosing class is
1603 such a class, etc. */
1606 namespace_bindings_p (void)
1608 struct cp_binding_level
*b
= innermost_nonclass_level ();
1610 return b
->kind
== sk_namespace
;
1613 /* True if the current level needs to have a BLOCK made. */
1618 return (current_binding_level
->blocks
!= NULL_TREE
1619 || current_binding_level
->keep
1620 || current_binding_level
->kind
== sk_cleanup
1621 || current_binding_level
->names
!= NULL_TREE
1622 || current_binding_level
->using_directives
);
1625 /* Returns the kind of the innermost scope. */
1628 innermost_scope_kind (void)
1630 return current_binding_level
->kind
;
1633 /* Returns true if this scope was created to store template parameters. */
1636 template_parm_scope_p (void)
1638 return innermost_scope_kind () == sk_template_parms
;
1641 /* If KEEP is true, make a BLOCK node for the next binding level,
1642 unconditionally. Otherwise, use the normal logic to decide whether
1643 or not to create a BLOCK. */
1646 keep_next_level (bool keep
)
1648 keep_next_level_flag
= keep
;
1651 /* Return the list of declarations of the current level.
1652 Note that this list is in reverse order unless/until
1653 you nreverse it; and when you do nreverse it, you must
1654 store the result back using `storedecls' or you will lose. */
1659 return current_binding_level
->names
;
1662 /* Return how many function prototypes we are currently nested inside. */
1665 function_parm_depth (void)
1668 struct cp_binding_level
*b
;
1670 for (b
= current_binding_level
;
1671 b
->kind
== sk_function_parms
;
1678 /* For debugging. */
1679 static int no_print_functions
= 0;
1680 static int no_print_builtins
= 0;
1683 print_binding_level (struct cp_binding_level
* lvl
)
1687 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1688 if (lvl
->more_cleanups_ok
)
1689 fprintf (stderr
, " more-cleanups-ok");
1690 if (lvl
->have_cleanups
)
1691 fprintf (stderr
, " have-cleanups");
1692 fprintf (stderr
, "\n");
1695 fprintf (stderr
, " names:\t");
1696 /* We can probably fit 3 names to a line? */
1697 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1699 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1701 if (no_print_builtins
1702 && (TREE_CODE (t
) == TYPE_DECL
)
1703 && DECL_IS_BUILTIN (t
))
1706 /* Function decls tend to have longer names. */
1707 if (TREE_CODE (t
) == FUNCTION_DECL
)
1714 fprintf (stderr
, "\n\t");
1717 print_node_brief (stderr
, "", t
, 0);
1718 if (t
== error_mark_node
)
1722 fprintf (stderr
, "\n");
1724 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1727 cp_class_binding
*b
;
1728 fprintf (stderr
, " class-shadowed:");
1729 FOR_EACH_VEC_ELT (cp_class_binding
, lvl
->class_shadowed
, i
, b
)
1730 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1731 fprintf (stderr
, "\n");
1733 if (lvl
->type_shadowed
)
1735 fprintf (stderr
, " type-shadowed:");
1736 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1738 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1740 fprintf (stderr
, "\n");
1745 print_other_binding_stack (struct cp_binding_level
*stack
)
1747 struct cp_binding_level
*level
;
1748 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1750 fprintf (stderr
, "binding level %p\n", (void *) level
);
1751 print_binding_level (level
);
1756 print_binding_stack (void)
1758 struct cp_binding_level
*b
;
1759 fprintf (stderr
, "current_binding_level=%p\n"
1760 "class_binding_level=%p\n"
1761 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1762 (void *) current_binding_level
, (void *) class_binding_level
,
1763 (void *) NAMESPACE_LEVEL (global_namespace
));
1764 if (class_binding_level
)
1766 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1767 if (b
== current_binding_level
)
1770 b
= class_binding_level
;
1772 b
= current_binding_level
;
1775 b
= current_binding_level
;
1776 print_other_binding_stack (b
);
1777 fprintf (stderr
, "global:\n");
1778 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1781 /* Return the type associated with ID. */
1784 identifier_type_value_1 (tree id
)
1786 /* There is no type with that name, anywhere. */
1787 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1789 /* This is not the type marker, but the real thing. */
1790 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1791 return REAL_IDENTIFIER_TYPE_VALUE (id
);
1792 /* Have to search for it. It must be on the global level, now.
1793 Ask lookup_name not to return non-types. */
1794 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1796 return TREE_TYPE (id
);
1800 /* Wrapper for identifier_type_value_1. */
1803 identifier_type_value (tree id
)
1806 timevar_start (TV_NAME_LOOKUP
);
1807 ret
= identifier_type_value_1 (id
);
1808 timevar_stop (TV_NAME_LOOKUP
);
1813 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1814 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1817 identifier_global_value (tree t
)
1819 return IDENTIFIER_GLOBAL_VALUE (t
);
1822 /* Push a definition of struct, union or enum tag named ID. into
1823 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1824 the tag ID is not already defined. */
1827 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1831 if (b
->kind
!= sk_namespace
)
1833 /* Shadow the marker, not the real thing, so that the marker
1834 gets restored later. */
1835 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1837 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1838 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1839 TREE_TYPE (b
->type_shadowed
) = type
;
1843 cxx_binding
*binding
=
1844 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1847 supplement_binding (binding
, decl
);
1849 binding
->value
= decl
;
1851 /* Store marker instead of real type. */
1852 type
= global_type_node
;
1854 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1857 /* As set_identifier_type_value_with_scope, but using
1858 current_binding_level. */
1861 set_identifier_type_value (tree id
, tree decl
)
1863 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1866 /* Return the name for the constructor (or destructor) for the
1867 specified class TYPE. When given a template, this routine doesn't
1868 lose the specialization. */
1871 constructor_name_full (tree type
)
1873 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1876 /* Return the name for the constructor (or destructor) for the
1877 specified class. When given a template, return the plain
1878 unspecialized name. */
1881 constructor_name (tree type
)
1884 name
= constructor_name_full (type
);
1885 if (IDENTIFIER_TEMPLATE (name
))
1886 name
= IDENTIFIER_TEMPLATE (name
);
1890 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1891 which must be a class type. */
1894 constructor_name_p (tree name
, tree type
)
1898 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
1903 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1906 ctor_name
= constructor_name_full (type
);
1907 if (name
== ctor_name
)
1909 if (IDENTIFIER_TEMPLATE (ctor_name
)
1910 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1915 /* Counter used to create anonymous type names. */
1917 static GTY(()) int anon_cnt
;
1919 /* Return an IDENTIFIER which can be used as a name for
1920 anonymous structs and unions. */
1923 make_anon_name (void)
1927 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1928 return get_identifier (buf
);
1931 /* This code is practically identical to that for creating
1932 anonymous names, but is just used for lambdas instead. This is necessary
1933 because anonymous names are recognized and cannot be passed to template
1935 /* FIXME is this still necessary? */
1937 static GTY(()) int lambda_cnt
= 0;
1940 make_lambda_name (void)
1944 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
1945 return get_identifier (buf
);
1948 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1950 static inline cxx_binding
*
1951 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1953 for (; binding
!= NULL
; binding
= binding
->previous
)
1954 if (binding
->scope
== scope
)
1957 return (cxx_binding
*)0;
1960 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1962 static inline cxx_binding
*
1963 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1965 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1968 /* Fold-in case where NAME is used only once. */
1969 if (scope
== b
->scope
&& b
->previous
== NULL
)
1971 return find_binding (scope
, b
);
1976 /* Always returns a binding for name in scope. If no binding is
1977 found, make a new one. */
1979 static cxx_binding
*
1980 binding_for_name (cxx_scope
*scope
, tree name
)
1982 cxx_binding
*result
;
1984 result
= cxx_scope_find_binding_for_name (scope
, name
);
1987 /* Not found, make a new one. */
1988 result
= cxx_binding_make (NULL
, NULL
);
1989 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1990 result
->scope
= scope
;
1991 result
->is_local
= false;
1992 result
->value_is_inherited
= false;
1993 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1997 /* Walk through the bindings associated to the name of FUNCTION,
1998 and return the first binding that declares a function with a
1999 "C" linkage specification, a.k.a 'extern "C"'.
2000 This function looks for the binding, regardless of which scope it
2001 has been defined in. It basically looks in all the known scopes.
2002 Note that this function does not lookup for bindings of builtin functions
2003 or for functions declared in system headers. */
2005 lookup_extern_c_fun_binding_in_all_ns (tree function
)
2010 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
2012 name
= DECL_NAME (function
);
2013 gcc_assert (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
);
2015 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2017 iter
= iter
->previous
)
2020 && TREE_CODE (iter
->value
) == FUNCTION_DECL
2021 && DECL_EXTERN_C_P (iter
->value
)
2022 && !DECL_ARTIFICIAL (iter
->value
))
2030 /* Insert another USING_DECL into the current binding level, returning
2031 this declaration. If this is a redeclaration, do nothing, and
2032 return NULL_TREE if this not in namespace scope (in namespace
2033 scope, a using decl might extend any previous bindings). */
2036 push_using_decl_1 (tree scope
, tree name
)
2040 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
2041 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
2042 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
2043 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
2046 return namespace_bindings_p () ? decl
: NULL_TREE
;
2047 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2048 USING_DECL_SCOPE (decl
) = scope
;
2049 DECL_CHAIN (decl
) = current_binding_level
->usings
;
2050 current_binding_level
->usings
= decl
;
2054 /* Wrapper for push_using_decl_1. */
2057 push_using_decl (tree scope
, tree name
)
2060 timevar_start (TV_NAME_LOOKUP
);
2061 ret
= push_using_decl_1 (scope
, name
);
2062 timevar_stop (TV_NAME_LOOKUP
);
2066 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2067 caller to set DECL_CONTEXT properly. */
2070 pushdecl_with_scope_1 (tree x
, cxx_scope
*level
, bool is_friend
)
2072 struct cp_binding_level
*b
;
2073 tree function_decl
= current_function_decl
;
2075 current_function_decl
= NULL_TREE
;
2076 if (level
->kind
== sk_class
)
2078 b
= class_binding_level
;
2079 class_binding_level
= level
;
2080 pushdecl_class_level (x
);
2081 class_binding_level
= b
;
2085 b
= current_binding_level
;
2086 current_binding_level
= level
;
2087 x
= pushdecl_maybe_friend (x
, is_friend
);
2088 current_binding_level
= b
;
2090 current_function_decl
= function_decl
;
2094 /* Wrapper for pushdecl_with_scope_1. */
2097 pushdecl_with_scope (tree x
, cxx_scope
*level
, bool is_friend
)
2100 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2101 ret
= pushdecl_with_scope_1 (x
, level
, is_friend
);
2102 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2107 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2108 other definitions already in place. We get around this by making
2109 the value of the identifier point to a list of all the things that
2110 want to be referenced by that name. It is then up to the users of
2111 that name to decide what to do with that list.
2113 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2114 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2116 FLAGS is a bitwise-or of the following values:
2117 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2119 PUSH_USING: DECL is being pushed as the result of a using
2122 IS_FRIEND is true if this is a friend declaration.
2124 The value returned may be a previous declaration if we guessed wrong
2125 about what language DECL should belong to (C or C++). Otherwise,
2126 it's always DECL (and never something that's not a _DECL). */
2129 push_overloaded_decl_1 (tree decl
, int flags
, bool is_friend
)
2131 tree name
= DECL_NAME (decl
);
2134 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2137 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2139 old
= lookup_name_innermost_nonclass_level (name
);
2143 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2145 tree t
= TREE_TYPE (old
);
2146 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2147 && (! DECL_IN_SYSTEM_HEADER (decl
)
2148 || ! DECL_IN_SYSTEM_HEADER (old
)))
2149 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2152 else if (is_overloaded_fn (old
))
2156 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2158 tree fn
= OVL_CURRENT (tmp
);
2161 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2162 && !(flags
& PUSH_USING
)
2163 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2164 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
2165 && ! decls_match (fn
, decl
))
2166 error ("%q#D conflicts with previous using declaration %q#D",
2169 dup
= duplicate_decls (decl
, fn
, is_friend
);
2170 /* If DECL was a redeclaration of FN -- even an invalid
2171 one -- pass that information along to our caller. */
2172 if (dup
== fn
|| dup
== error_mark_node
)
2176 /* We don't overload implicit built-ins. duplicate_decls()
2177 may fail to merge the decls if the new decl is e.g. a
2178 template function. */
2179 if (TREE_CODE (old
) == FUNCTION_DECL
2180 && DECL_ANTICIPATED (old
)
2181 && !DECL_HIDDEN_FRIEND_P (old
))
2184 else if (old
== error_mark_node
)
2185 /* Ignore the undefined symbol marker. */
2189 error ("previous non-function declaration %q+#D", old
);
2190 error ("conflicts with function declaration %q#D", decl
);
2195 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2196 /* If it's a using declaration, we always need to build an OVERLOAD,
2197 because it's the only way to remember that the declaration comes
2198 from 'using', and have the lookup behave correctly. */
2199 || (flags
& PUSH_USING
))
2201 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2202 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2204 new_binding
= ovl_cons (decl
, old
);
2205 if (flags
& PUSH_USING
)
2206 OVL_USED (new_binding
) = 1;
2209 /* NAME is not ambiguous. */
2213 set_namespace_binding (name
, current_namespace
, new_binding
);
2216 /* We only create an OVERLOAD if there was a previous binding at
2217 this level, or if decl is a template. In the former case, we
2218 need to remove the old binding and replace it with the new
2219 binding. We must also run through the NAMES on the binding
2220 level where the name was bound to update the chain. */
2222 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2226 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2228 d
= &TREE_CHAIN (*d
))
2230 || (TREE_CODE (*d
) == TREE_LIST
2231 && TREE_VALUE (*d
) == old
))
2233 if (TREE_CODE (*d
) == TREE_LIST
)
2234 /* Just replace the old binding with the new. */
2235 TREE_VALUE (*d
) = new_binding
;
2237 /* Build a TREE_LIST to wrap the OVERLOAD. */
2238 *d
= tree_cons (NULL_TREE
, new_binding
,
2241 /* And update the cxx_binding node. */
2242 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2246 /* We should always find a previous binding in this case. */
2250 /* Install the new binding. */
2251 push_local_binding (name
, new_binding
, flags
);
2257 /* Wrapper for push_overloaded_decl_1. */
2260 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2263 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2264 ret
= push_overloaded_decl_1 (decl
, flags
, is_friend
);
2265 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2269 /* Check a non-member using-declaration. Return the name and scope
2270 being used, and the USING_DECL, or NULL_TREE on failure. */
2273 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2275 /* [namespace.udecl]
2276 A using-declaration for a class member shall be a
2277 member-declaration. */
2280 error ("%qT is not a namespace", scope
);
2283 else if (scope
== error_mark_node
)
2286 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2289 A using-declaration shall not name a template-id. */
2290 error ("a using-declaration cannot specify a template-id. "
2291 "Try %<using %D%>", name
);
2295 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2297 error ("namespace %qD not allowed in using-declaration", decl
);
2301 if (TREE_CODE (decl
) == SCOPE_REF
)
2303 /* It's a nested name with template parameter dependent scope.
2304 This can only be using-declaration for class member. */
2305 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2309 if (is_overloaded_fn (decl
))
2310 decl
= get_first_fn (decl
);
2312 gcc_assert (DECL_P (decl
));
2314 /* Make a USING_DECL. */
2315 return push_using_decl (scope
, name
);
2318 /* Process local and global using-declarations. */
2321 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2322 tree
*newval
, tree
*newtype
)
2324 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2326 *newval
= *newtype
= NULL_TREE
;
2327 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2331 if (!decls
.value
&& !decls
.type
)
2333 error ("%qD not declared", name
);
2337 /* Shift the old and new bindings around so we're comparing class and
2338 enumeration names to each other. */
2339 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2345 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2347 decls
.type
= decls
.value
;
2348 decls
.value
= NULL_TREE
;
2351 /* It is impossible to overload a built-in function; any explicit
2352 declaration eliminates the built-in declaration. So, if OLDVAL
2353 is a built-in, then we can just pretend it isn't there. */
2355 && TREE_CODE (oldval
) == FUNCTION_DECL
2356 && DECL_ANTICIPATED (oldval
)
2357 && !DECL_HIDDEN_FRIEND_P (oldval
))
2362 /* Check for using functions. */
2363 if (is_overloaded_fn (decls
.value
))
2367 if (oldval
&& !is_overloaded_fn (oldval
))
2369 error ("%qD is already declared in this scope", name
);
2374 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2376 tree new_fn
= OVL_CURRENT (tmp
);
2378 /* [namespace.udecl]
2380 If a function declaration in namespace scope or block
2381 scope has the same name and the same parameter types as a
2382 function introduced by a using declaration the program is
2384 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2386 tree old_fn
= OVL_CURRENT (tmp1
);
2388 if (new_fn
== old_fn
)
2389 /* The function already exists in the current namespace. */
2391 else if (OVL_USED (tmp1
))
2392 continue; /* this is a using decl */
2393 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2394 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2396 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2397 || DECL_HIDDEN_FRIEND_P (old_fn
));
2399 /* There was already a non-using declaration in
2400 this scope with the same parameter types. If both
2401 are the same extern "C" functions, that's ok. */
2402 if (decls_match (new_fn
, old_fn
))
2406 error ("%qD is already declared in this scope", name
);
2412 /* If we broke out of the loop, there's no reason to add
2413 this function to the using declarations for this
2418 /* If we are adding to an existing OVERLOAD, then we no
2419 longer know the type of the set of functions. */
2420 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2421 TREE_TYPE (*newval
) = unknown_type_node
;
2422 /* Add this new function to the set. */
2423 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2424 /* If there is only one function, then we use its type. (A
2425 using-declaration naming a single function can be used in
2426 contexts where overload resolution cannot be
2428 if (TREE_CODE (*newval
) != OVERLOAD
)
2430 *newval
= ovl_cons (*newval
, NULL_TREE
);
2431 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2433 OVL_USED (*newval
) = 1;
2438 *newval
= decls
.value
;
2439 if (oldval
&& !decls_match (*newval
, oldval
))
2440 error ("%qD is already declared in this scope", name
);
2446 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2448 error ("reference to %qD is ambiguous", name
);
2449 print_candidates (decls
.type
);
2453 *newtype
= decls
.type
;
2454 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2455 error ("%qD is already declared in this scope", name
);
2458 /* If *newval is empty, shift any class or enumeration name down. */
2462 *newtype
= NULL_TREE
;
2466 /* Process a using-declaration at function scope. */
2469 do_local_using_decl (tree decl
, tree scope
, tree name
)
2471 tree oldval
, oldtype
, newval
, newtype
;
2472 tree orig_decl
= decl
;
2474 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2475 if (decl
== NULL_TREE
)
2478 if (building_stmt_tree ()
2479 && at_function_scope_p ())
2480 add_decl_expr (decl
);
2482 oldval
= lookup_name_innermost_nonclass_level (name
);
2483 oldtype
= lookup_type_current_level (name
);
2485 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2489 if (is_overloaded_fn (newval
))
2493 /* We only need to push declarations for those functions
2494 that were not already bound in the current level.
2495 The old value might be NULL_TREE, it might be a single
2496 function, or an OVERLOAD. */
2497 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2498 term
= OVL_FUNCTION (oldval
);
2501 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2503 push_overloaded_decl (OVL_CURRENT (fn
),
2504 PUSH_LOCAL
| PUSH_USING
,
2508 push_local_binding (name
, newval
, PUSH_USING
);
2512 push_local_binding (name
, newtype
, PUSH_USING
);
2513 set_identifier_type_value (name
, newtype
);
2516 /* Emit debug info. */
2517 if (!processing_template_decl
)
2518 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2521 /* Returns true if ROOT (a namespace, class, or function) encloses
2522 CHILD. CHILD may be either a class type or a namespace. */
2525 is_ancestor (tree root
, tree child
)
2527 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2528 || TREE_CODE (root
) == FUNCTION_DECL
2529 || CLASS_TYPE_P (root
)));
2530 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2531 || CLASS_TYPE_P (child
)));
2533 /* The global namespace encloses everything. */
2534 if (root
== global_namespace
)
2539 /* If we've run out of scopes, stop. */
2542 /* If we've reached the ROOT, it encloses CHILD. */
2545 /* Go out one level. */
2547 child
= TYPE_NAME (child
);
2548 child
= DECL_CONTEXT (child
);
2552 /* Enter the class or namespace scope indicated by T suitable for name
2553 lookup. T can be arbitrary scope, not necessary nested inside the
2554 current scope. Returns a non-null scope to pop iff pop_scope
2555 should be called later to exit this scope. */
2560 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2561 push_decl_namespace (t
);
2562 else if (CLASS_TYPE_P (t
))
2564 if (!at_class_scope_p ()
2565 || !same_type_p (current_class_type
, t
))
2566 push_nested_class (t
);
2568 /* T is the same as the current scope. There is therefore no
2569 need to re-enter the scope. Since we are not actually
2570 pushing a new scope, our caller should not call
2578 /* Leave scope pushed by push_scope. */
2585 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2586 pop_decl_namespace ();
2587 else if CLASS_TYPE_P (t
)
2588 pop_nested_class ();
2591 /* Subroutine of push_inner_scope. */
2594 push_inner_scope_r (tree outer
, tree inner
)
2599 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2602 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2604 push_inner_scope_r (outer
, prev
);
2605 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2607 struct cp_binding_level
*save_template_parm
= 0;
2608 /* Temporary take out template parameter scopes. They are saved
2609 in reversed order in save_template_parm. */
2610 while (current_binding_level
->kind
== sk_template_parms
)
2612 struct cp_binding_level
*b
= current_binding_level
;
2613 current_binding_level
= b
->level_chain
;
2614 b
->level_chain
= save_template_parm
;
2615 save_template_parm
= b
;
2618 resume_scope (NAMESPACE_LEVEL (inner
));
2619 current_namespace
= inner
;
2621 /* Restore template parameter scopes. */
2622 while (save_template_parm
)
2624 struct cp_binding_level
*b
= save_template_parm
;
2625 save_template_parm
= b
->level_chain
;
2626 b
->level_chain
= current_binding_level
;
2627 current_binding_level
= b
;
2634 /* Enter the scope INNER from current scope. INNER must be a scope
2635 nested inside current scope. This works with both name lookup and
2636 pushing name into scope. In case a template parameter scope is present,
2637 namespace is pushed under the template parameter scope according to
2638 name lookup rule in 14.6.1/6.
2640 Return the former current scope suitable for pop_inner_scope. */
2643 push_inner_scope (tree inner
)
2645 tree outer
= current_scope ();
2647 outer
= current_namespace
;
2649 push_inner_scope_r (outer
, inner
);
2653 /* Exit the current scope INNER back to scope OUTER. */
2656 pop_inner_scope (tree outer
, tree inner
)
2659 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2662 while (outer
!= inner
)
2664 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2666 struct cp_binding_level
*save_template_parm
= 0;
2667 /* Temporary take out template parameter scopes. They are saved
2668 in reversed order in save_template_parm. */
2669 while (current_binding_level
->kind
== sk_template_parms
)
2671 struct cp_binding_level
*b
= current_binding_level
;
2672 current_binding_level
= b
->level_chain
;
2673 b
->level_chain
= save_template_parm
;
2674 save_template_parm
= b
;
2679 /* Restore template parameter scopes. */
2680 while (save_template_parm
)
2682 struct cp_binding_level
*b
= save_template_parm
;
2683 save_template_parm
= b
->level_chain
;
2684 b
->level_chain
= current_binding_level
;
2685 current_binding_level
= b
;
2691 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2695 /* Do a pushlevel for class declarations. */
2698 pushlevel_class (void)
2700 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2703 /* ...and a poplevel for class declarations. */
2706 poplevel_class (void)
2708 struct cp_binding_level
*level
= class_binding_level
;
2709 cp_class_binding
*cb
;
2713 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2714 gcc_assert (level
!= 0);
2716 /* If we're leaving a toplevel class, cache its binding level. */
2717 if (current_class_depth
== 1)
2718 previous_class_level
= level
;
2719 for (shadowed
= level
->type_shadowed
;
2721 shadowed
= TREE_CHAIN (shadowed
))
2722 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2724 /* Remove the bindings for all of the class-level declarations. */
2725 if (level
->class_shadowed
)
2727 FOR_EACH_VEC_ELT (cp_class_binding
, level
->class_shadowed
, i
, cb
)
2728 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
.previous
;
2729 ggc_free (level
->class_shadowed
);
2730 level
->class_shadowed
= NULL
;
2733 /* Now, pop out of the binding level which we created up in the
2734 `pushlevel_class' routine. */
2735 gcc_assert (current_binding_level
== level
);
2737 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2740 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2741 appropriate. DECL is the value to which a name has just been
2742 bound. CLASS_TYPE is the class in which the lookup occurred. */
2745 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2748 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2752 if (TREE_CODE (decl
) == OVERLOAD
)
2753 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2756 gcc_assert (DECL_P (decl
));
2757 context
= context_for_name_lookup (decl
);
2760 if (is_properly_derived_from (class_type
, context
))
2761 INHERITED_VALUE_BINDING_P (binding
) = 1;
2763 INHERITED_VALUE_BINDING_P (binding
) = 0;
2765 else if (binding
->value
== decl
)
2766 /* We only encounter a TREE_LIST when there is an ambiguity in the
2767 base classes. Such an ambiguity can be overridden by a
2768 definition in this class. */
2769 INHERITED_VALUE_BINDING_P (binding
) = 1;
2771 INHERITED_VALUE_BINDING_P (binding
) = 0;
2774 /* Make the declaration of X appear in CLASS scope. */
2777 pushdecl_class_level (tree x
)
2780 bool is_valid
= true;
2783 /* Do nothing if we're adding to an outer lambda closure type,
2784 outer_binding will add it later if it's needed. */
2785 if (current_class_type
!= class_binding_level
->this_entity
)
2788 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2789 /* Get the name of X. */
2790 if (TREE_CODE (x
) == OVERLOAD
)
2791 name
= DECL_NAME (get_first_fn (x
));
2793 name
= DECL_NAME (x
);
2797 is_valid
= push_class_level_binding (name
, x
);
2798 if (TREE_CODE (x
) == TYPE_DECL
)
2799 set_identifier_type_value (name
, x
);
2801 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2803 /* If X is an anonymous aggregate, all of its members are
2804 treated as if they were members of the class containing the
2805 aggregate, for naming purposes. */
2808 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= DECL_CHAIN (f
))
2810 location_t save_location
= input_location
;
2811 input_location
= DECL_SOURCE_LOCATION (f
);
2812 if (!pushdecl_class_level (f
))
2814 input_location
= save_location
;
2817 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2821 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2822 scope. If the value returned is non-NULL, and the PREVIOUS field
2823 is not set, callers must set the PREVIOUS field explicitly. */
2825 static cxx_binding
*
2826 get_class_binding (tree name
, cxx_scope
*scope
)
2831 cxx_binding
*binding
;
2833 class_type
= scope
->this_entity
;
2835 /* Get the type binding. */
2836 type_binding
= lookup_member (class_type
, name
,
2837 /*protect=*/2, /*want_type=*/true);
2838 /* Get the value binding. */
2839 value_binding
= lookup_member (class_type
, name
,
2840 /*protect=*/2, /*want_type=*/false);
2843 && (TREE_CODE (value_binding
) == TYPE_DECL
2844 || DECL_CLASS_TEMPLATE_P (value_binding
)
2845 || (TREE_CODE (value_binding
) == TREE_LIST
2846 && TREE_TYPE (value_binding
) == error_mark_node
2847 && (TREE_CODE (TREE_VALUE (value_binding
))
2849 /* We found a type binding, even when looking for a non-type
2850 binding. This means that we already processed this binding
2853 else if (value_binding
)
2855 if (TREE_CODE (value_binding
) == TREE_LIST
2856 && TREE_TYPE (value_binding
) == error_mark_node
)
2857 /* NAME is ambiguous. */
2859 else if (BASELINK_P (value_binding
))
2860 /* NAME is some overloaded functions. */
2861 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2864 /* If we found either a type binding or a value binding, create a
2865 new binding object. */
2866 if (type_binding
|| value_binding
)
2868 binding
= new_class_binding (name
,
2872 /* This is a class-scope binding, not a block-scope binding. */
2873 LOCAL_BINDING_P (binding
) = 0;
2874 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2882 /* Make the declaration(s) of X appear in CLASS scope under the name
2883 NAME. Returns true if the binding is valid. */
2886 push_class_level_binding_1 (tree name
, tree x
)
2888 cxx_binding
*binding
;
2892 /* The class_binding_level will be NULL if x is a template
2893 parameter name in a member template. */
2894 if (!class_binding_level
)
2897 if (name
== error_mark_node
)
2900 /* Check for invalid member names. */
2901 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2902 /* Check that we're pushing into the right binding level. */
2903 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
2905 /* We could have been passed a tree list if this is an ambiguous
2906 declaration. If so, pull the declaration out because
2907 check_template_shadow will not handle a TREE_LIST. */
2908 if (TREE_CODE (decl
) == TREE_LIST
2909 && TREE_TYPE (decl
) == error_mark_node
)
2910 decl
= TREE_VALUE (decl
);
2912 if (!check_template_shadow (decl
))
2917 If T is the name of a class, then each of the following shall
2918 have a name different from T:
2920 -- every static data member of class T;
2922 -- every member of class T that is itself a type;
2924 -- every enumerator of every member of class T that is an
2927 -- every member of every anonymous union that is a member of
2930 (Non-static data members were also forbidden to have the same
2931 name as T until TC1.) */
2932 if ((TREE_CODE (x
) == VAR_DECL
2933 || TREE_CODE (x
) == CONST_DECL
2934 || (TREE_CODE (x
) == TYPE_DECL
2935 && !DECL_SELF_REFERENCE_P (x
))
2936 /* A data member of an anonymous union. */
2937 || (TREE_CODE (x
) == FIELD_DECL
2938 && DECL_CONTEXT (x
) != current_class_type
))
2939 && DECL_NAME (x
) == constructor_name (current_class_type
))
2941 tree scope
= context_for_name_lookup (x
);
2942 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
2944 error ("%qD has the same name as the class in which it is "
2951 /* Get the current binding for NAME in this class, if any. */
2952 binding
= IDENTIFIER_BINDING (name
);
2953 if (!binding
|| binding
->scope
!= class_binding_level
)
2955 binding
= get_class_binding (name
, class_binding_level
);
2956 /* If a new binding was created, put it at the front of the
2957 IDENTIFIER_BINDING list. */
2960 binding
->previous
= IDENTIFIER_BINDING (name
);
2961 IDENTIFIER_BINDING (name
) = binding
;
2965 /* If there is already a binding, then we may need to update the
2967 if (binding
&& binding
->value
)
2969 tree bval
= binding
->value
;
2970 tree old_decl
= NULL_TREE
;
2972 if (INHERITED_VALUE_BINDING_P (binding
))
2974 /* If the old binding was from a base class, and was for a
2975 tag name, slide it over to make room for the new binding.
2976 The old binding is still visible if explicitly qualified
2977 with a class-key. */
2978 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2979 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2981 old_decl
= binding
->type
;
2982 binding
->type
= bval
;
2983 binding
->value
= NULL_TREE
;
2984 INHERITED_VALUE_BINDING_P (binding
) = 0;
2989 /* Any inherited type declaration is hidden by the type
2990 declaration in the derived class. */
2991 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
))
2992 binding
->type
= NULL_TREE
;
2995 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2997 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2999 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
3001 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
3004 if (old_decl
&& binding
->scope
== class_binding_level
)
3007 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3008 here. This function is only used to register bindings
3009 from with the class definition itself. */
3010 INHERITED_VALUE_BINDING_P (binding
) = 0;
3015 /* Note that we declared this value so that we can issue an error if
3016 this is an invalid redeclaration of a name already used for some
3018 note_name_declared_in_class (name
, decl
);
3020 /* If we didn't replace an existing binding, put the binding on the
3021 stack of bindings for the identifier, and update the shadowed
3023 if (binding
&& binding
->scope
== class_binding_level
)
3024 /* Supplement the existing binding. */
3025 ok
= supplement_binding (binding
, decl
);
3028 /* Create a new binding. */
3029 push_binding (name
, decl
, class_binding_level
);
3036 /* Wrapper for push_class_level_binding_1. */
3039 push_class_level_binding (tree name
, tree x
)
3042 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3043 ret
= push_class_level_binding_1 (name
, x
);
3044 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3048 /* Process "using SCOPE::NAME" in a class scope. Return the
3049 USING_DECL created. */
3052 do_class_using_decl (tree scope
, tree name
)
3054 /* The USING_DECL returned by this function. */
3056 /* The declaration (or declarations) name by this using
3057 declaration. NULL if we are in a template and cannot figure out
3058 what has been named. */
3060 /* True if SCOPE is a dependent type. */
3061 bool scope_dependent_p
;
3062 /* True if SCOPE::NAME is dependent. */
3063 bool name_dependent_p
;
3064 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3065 bool bases_dependent_p
;
3070 if (name
== error_mark_node
)
3073 if (!scope
|| !TYPE_P (scope
))
3075 error ("using-declaration for non-member at class scope");
3079 /* Make sure the name is not invalid */
3080 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
3082 error ("%<%T::%D%> names destructor", scope
, name
);
3085 if (MAYBE_CLASS_TYPE_P (scope
) && constructor_name_p (name
, scope
))
3087 error ("%<%T::%D%> names constructor", scope
, name
);
3090 if (constructor_name_p (name
, current_class_type
))
3092 error ("%<%T::%D%> names constructor in %qT",
3093 scope
, name
, current_class_type
);
3097 scope_dependent_p
= dependent_type_p (scope
);
3098 name_dependent_p
= (scope_dependent_p
3099 || (IDENTIFIER_TYPENAME_P (name
)
3100 && dependent_type_p (TREE_TYPE (name
))));
3102 bases_dependent_p
= false;
3103 if (processing_template_decl
)
3104 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3105 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
3107 if (dependent_type_p (TREE_TYPE (base_binfo
)))
3109 bases_dependent_p
= true;
3115 /* From [namespace.udecl]:
3117 A using-declaration used as a member-declaration shall refer to a
3118 member of a base class of the class being defined.
3120 In general, we cannot check this constraint in a template because
3121 we do not know the entire set of base classes of the current
3122 class type. However, if all of the base classes are
3123 non-dependent, then we can avoid delaying the check until
3125 if (!scope_dependent_p
)
3128 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
3129 if (b_kind
< bk_proper_base
)
3131 if (!bases_dependent_p
)
3133 error_not_base_type (scope
, current_class_type
);
3137 else if (!name_dependent_p
)
3139 decl
= lookup_member (binfo
, name
, 0, false);
3142 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
3146 /* The binfo from which the functions came does not matter. */
3147 if (BASELINK_P (decl
))
3148 decl
= BASELINK_FUNCTIONS (decl
);
3152 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3153 USING_DECL_DECLS (value
) = decl
;
3154 USING_DECL_SCOPE (value
) = scope
;
3155 DECL_DEPENDENT_P (value
) = !decl
;
3161 /* Return the binding value for name in scope. */
3165 namespace_binding_1 (tree name
, tree scope
)
3167 cxx_binding
*binding
;
3169 if (SCOPE_FILE_SCOPE_P (scope
))
3170 scope
= global_namespace
;
3172 /* Unnecessary for the global namespace because it can't be an alias. */
3173 scope
= ORIGINAL_NAMESPACE (scope
);
3175 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3177 return binding
? binding
->value
: NULL_TREE
;
3181 namespace_binding (tree name
, tree scope
)
3184 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3185 ret
= namespace_binding_1 (name
, scope
);
3186 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3190 /* Set the binding value for name in scope. */
3193 set_namespace_binding_1 (tree name
, tree scope
, tree val
)
3197 if (scope
== NULL_TREE
)
3198 scope
= global_namespace
;
3199 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3200 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3203 supplement_binding (b
, val
);
3206 /* Wrapper for set_namespace_binding_1. */
3209 set_namespace_binding (tree name
, tree scope
, tree val
)
3211 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3212 set_namespace_binding_1 (name
, scope
, val
);
3213 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3216 /* Set the context of a declaration to scope. Complain if we are not
3220 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3224 /* Get rid of namespace aliases. */
3225 scope
= ORIGINAL_NAMESPACE (scope
);
3227 /* It is ok for friends to be qualified in parallel space. */
3228 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3229 error ("declaration of %qD not in a namespace surrounding %qD",
3231 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3233 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3234 if (scope
== current_namespace
)
3236 if (at_namespace_scope_p ())
3237 error ("explicit qualification in declaration of %qD",
3242 /* See whether this has been declared in the namespace. */
3243 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3244 if (old
== error_mark_node
)
3245 /* No old declaration at all. */
3247 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3248 if (TREE_CODE (old
) == TREE_LIST
)
3250 error ("reference to %qD is ambiguous", decl
);
3251 print_candidates (old
);
3254 if (!is_overloaded_fn (decl
))
3256 /* We might have found OLD in an inline namespace inside SCOPE. */
3257 if (TREE_CODE (decl
) == TREE_CODE (old
))
3258 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3259 /* Don't compare non-function decls with decls_match here, since
3260 it can't check for the correct constness at this
3261 point. pushdecl will find those errors later. */
3264 /* Since decl is a function, old should contain a function decl. */
3265 if (!is_overloaded_fn (old
))
3267 /* A template can be explicitly specialized in any namespace. */
3268 if (processing_explicit_instantiation
)
3270 if (processing_template_decl
|| processing_specialization
)
3271 /* We have not yet called push_template_decl to turn a
3272 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3273 match. But, we'll check later, when we construct the
3276 /* Instantiations or specializations of templates may be declared as
3277 friends in any namespace. */
3278 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3280 if (is_overloaded_fn (old
))
3282 tree found
= NULL_TREE
;
3284 for (; elt
; elt
= OVL_NEXT (elt
))
3286 tree ofn
= OVL_CURRENT (elt
);
3287 /* Adjust DECL_CONTEXT first so decls_match will return true
3288 if DECL will match a declaration in an inline namespace. */
3289 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
3290 if (decls_match (decl
, ofn
))
3292 if (found
&& !decls_match (found
, ofn
))
3294 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3295 error ("reference to %qD is ambiguous", decl
);
3296 print_candidates (old
);
3304 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (found
)))
3306 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
3312 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3313 if (decls_match (decl
, old
))
3317 /* It didn't work, go back to the explicit scope. */
3318 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3320 error ("%qD should have been declared inside %qD", decl
, scope
);
3323 /* Return the namespace where the current declaration is declared. */
3326 current_decl_namespace (void)
3329 /* If we have been pushed into a different namespace, use it. */
3330 if (!VEC_empty (tree
, decl_namespace_list
))
3331 return VEC_last (tree
, decl_namespace_list
);
3333 if (current_class_type
)
3334 result
= decl_namespace_context (current_class_type
);
3335 else if (current_function_decl
)
3336 result
= decl_namespace_context (current_function_decl
);
3338 result
= current_namespace
;
3342 /* Process any ATTRIBUTES on a namespace definition. Currently only
3343 attribute visibility is meaningful, which is a property of the syntactic
3344 block rather than the namespace as a whole, so we don't touch the
3345 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3348 handle_namespace_attrs (tree ns
, tree attributes
)
3351 bool saw_vis
= false;
3353 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3355 tree name
= TREE_PURPOSE (d
);
3356 tree args
= TREE_VALUE (d
);
3358 if (is_attribute_p ("visibility", name
))
3360 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3361 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3363 warning (OPT_Wattributes
,
3364 "%qD attribute requires a single NTBS argument",
3369 if (!TREE_PUBLIC (ns
))
3370 warning (OPT_Wattributes
,
3371 "%qD attribute is meaningless since members of the "
3372 "anonymous namespace get local symbols", name
);
3374 push_visibility (TREE_STRING_POINTER (x
), 1);
3379 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3388 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3389 select a name that is unique to this compilation unit. */
3392 push_namespace (tree name
)
3396 int implicit_use
= 0;
3399 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3401 /* We should not get here if the global_namespace is not yet constructed
3402 nor if NAME designates the global namespace: The global scope is
3403 constructed elsewhere. */
3404 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3408 name
= get_anonymous_namespace_name();
3409 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3411 /* Reopening anonymous namespace. */
3417 /* Check whether this is an extended namespace definition. */
3418 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3419 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3422 if (DECL_NAMESPACE_ALIAS (d
))
3424 error ("namespace alias %qD not allowed here, assuming %qD",
3425 d
, DECL_NAMESPACE_ALIAS (d
));
3426 d
= DECL_NAMESPACE_ALIAS (d
);
3433 /* Make a new namespace, binding the name to it. */
3434 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3435 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3436 /* The name of this namespace is not visible to other translation
3437 units if it is an anonymous namespace or member thereof. */
3438 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3439 TREE_PUBLIC (d
) = 0;
3441 TREE_PUBLIC (d
) = 1;
3445 /* Clear DECL_NAME for the benefit of debugging back ends. */
3446 SET_DECL_ASSEMBLER_NAME (d
, name
);
3447 DECL_NAME (d
) = NULL_TREE
;
3449 begin_scope (sk_namespace
, d
);
3452 resume_scope (NAMESPACE_LEVEL (d
));
3455 do_using_directive (d
);
3456 /* Enter the name space. */
3457 current_namespace
= d
;
3459 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3462 /* Pop from the scope of the current namespace. */
3465 pop_namespace (void)
3467 gcc_assert (current_namespace
!= global_namespace
);
3468 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3469 /* The binding level is not popped, as it might be re-opened later. */
3473 /* Push into the scope of the namespace NS, even if it is deeply
3474 nested within another namespace. */
3477 push_nested_namespace (tree ns
)
3479 if (ns
== global_namespace
)
3480 push_to_top_level ();
3483 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3484 push_namespace (DECL_NAME (ns
));
3488 /* Pop back from the scope of the namespace NS, which was previously
3489 entered with push_nested_namespace. */
3492 pop_nested_namespace (tree ns
)
3494 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3495 gcc_assert (current_namespace
== ns
);
3496 while (ns
!= global_namespace
)
3499 ns
= CP_DECL_CONTEXT (ns
);
3502 pop_from_top_level ();
3503 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3506 /* Temporarily set the namespace for the current declaration. */
3509 push_decl_namespace (tree decl
)
3511 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3512 decl
= decl_namespace_context (decl
);
3513 VEC_safe_push (tree
, gc
, decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
3516 /* [namespace.memdef]/2 */
3519 pop_decl_namespace (void)
3521 VEC_pop (tree
, decl_namespace_list
);
3524 /* Return the namespace that is the common ancestor
3525 of two given namespaces. */
3528 namespace_ancestor_1 (tree ns1
, tree ns2
)
3531 if (is_ancestor (ns1
, ns2
))
3534 nsr
= namespace_ancestor_1 (CP_DECL_CONTEXT (ns1
), ns2
);
3538 /* Wrapper for namespace_ancestor_1. */
3541 namespace_ancestor (tree ns1
, tree ns2
)
3544 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3545 nsr
= namespace_ancestor_1 (ns1
, ns2
);
3546 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3550 /* Process a namespace-alias declaration. */
3553 do_namespace_alias (tree alias
, tree name_space
)
3555 if (name_space
== error_mark_node
)
3558 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3560 name_space
= ORIGINAL_NAMESPACE (name_space
);
3562 /* Build the alias. */
3563 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3564 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3565 DECL_EXTERNAL (alias
) = 1;
3566 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3569 /* Emit debug info for namespace alias. */
3570 if (!building_stmt_tree ())
3571 (*debug_hooks
->global_decl
) (alias
);
3574 /* Like pushdecl, only it places X in the current namespace,
3578 pushdecl_namespace_level (tree x
, bool is_friend
)
3580 struct cp_binding_level
*b
= current_binding_level
;
3583 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3584 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3586 /* Now, the type_shadowed stack may screw us. Munge it so it does
3588 if (TREE_CODE (t
) == TYPE_DECL
)
3590 tree name
= DECL_NAME (t
);
3592 tree
*ptr
= (tree
*)0;
3593 for (; !global_scope_p (b
); b
= b
->level_chain
)
3595 tree shadowed
= b
->type_shadowed
;
3596 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3597 if (TREE_PURPOSE (shadowed
) == name
)
3599 ptr
= &TREE_VALUE (shadowed
);
3600 /* Can't break out of the loop here because sometimes
3601 a binding level will have duplicate bindings for
3602 PT names. It's gross, but I haven't time to fix it. */
3605 newval
= TREE_TYPE (t
);
3606 if (ptr
== (tree
*)0)
3608 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3609 up here if this is changed to an assertion. --KR */
3610 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3617 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3621 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3622 directive is not directly from the source. Also find the common
3623 ancestor and let our users know about the new namespace */
3626 add_using_namespace_1 (tree user
, tree used
, bool indirect
)
3629 /* Using oneself is a no-op. */
3632 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3633 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3634 /* Check if we already have this. */
3635 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3639 /* Promote to direct usage. */
3640 TREE_INDIRECT_USING (t
) = 0;
3644 /* Add used to the user's using list. */
3645 DECL_NAMESPACE_USING (user
)
3646 = tree_cons (used
, namespace_ancestor (user
, used
),
3647 DECL_NAMESPACE_USING (user
));
3649 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3651 /* Add user to the used's users list. */
3652 DECL_NAMESPACE_USERS (used
)
3653 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3655 /* Recursively add all namespaces used. */
3656 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3657 /* indirect usage */
3658 add_using_namespace_1 (user
, TREE_PURPOSE (t
), 1);
3660 /* Tell everyone using us about the new used namespaces. */
3661 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3662 add_using_namespace_1 (TREE_PURPOSE (t
), used
, 1);
3665 /* Wrapper for add_using_namespace_1. */
3668 add_using_namespace (tree user
, tree used
, bool indirect
)
3670 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3671 add_using_namespace_1 (user
, used
, indirect
);
3672 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3675 /* Process a using-declaration not appearing in class or local scope. */
3678 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3680 tree oldval
, oldtype
, newval
, newtype
;
3681 tree orig_decl
= decl
;
3682 cxx_binding
*binding
;
3684 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3685 if (decl
== NULL_TREE
)
3688 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3690 oldval
= binding
->value
;
3691 oldtype
= binding
->type
;
3693 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3695 /* Emit debug info. */
3696 if (!processing_template_decl
)
3697 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3699 /* Copy declarations found. */
3701 binding
->value
= newval
;
3703 binding
->type
= newtype
;
3706 /* Process a using-directive. */
3709 do_using_directive (tree name_space
)
3711 tree context
= NULL_TREE
;
3713 if (name_space
== error_mark_node
)
3716 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3718 if (building_stmt_tree ())
3719 add_stmt (build_stmt (input_location
, USING_STMT
, name_space
));
3720 name_space
= ORIGINAL_NAMESPACE (name_space
);
3722 if (!toplevel_bindings_p ())
3724 push_using_directive (name_space
);
3729 add_using_namespace (current_namespace
, name_space
, 0);
3730 if (current_namespace
!= global_namespace
)
3731 context
= current_namespace
;
3733 /* Emit debugging info. */
3734 if (!processing_template_decl
)
3735 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
3740 /* Deal with a using-directive seen by the parser. Currently we only
3741 handle attributes here, since they cannot appear inside a template. */
3744 parse_using_directive (tree name_space
, tree attribs
)
3748 do_using_directive (name_space
);
3750 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3752 tree name
= TREE_PURPOSE (a
);
3753 if (is_attribute_p ("strong", name
))
3755 if (!toplevel_bindings_p ())
3756 error ("strong using only meaningful at namespace scope");
3757 else if (name_space
!= error_mark_node
)
3759 if (!is_ancestor (current_namespace
, name_space
))
3760 error ("current namespace %qD does not enclose strongly used namespace %qD",
3761 current_namespace
, name_space
);
3762 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
3763 = tree_cons (current_namespace
, 0,
3764 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
3768 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3772 /* Like pushdecl, only it places X in the global scope if appropriate.
3773 Calls cp_finish_decl to register the variable, initializing it with
3774 *INIT, if INIT is non-NULL. */
3777 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3779 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3780 push_to_top_level ();
3781 x
= pushdecl_namespace_level (x
, is_friend
);
3783 cp_finish_decl (x
, *init
, false, NULL_TREE
, 0);
3784 pop_from_top_level ();
3785 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3789 /* Like pushdecl, only it places X in the global scope if appropriate. */
3792 pushdecl_top_level (tree x
)
3794 return pushdecl_top_level_1 (x
, NULL
, false);
3797 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3800 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3802 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3805 /* Like pushdecl, only it places X in the global scope if
3806 appropriate. Calls cp_finish_decl to register the variable,
3807 initializing it with INIT. */
3810 pushdecl_top_level_and_finish (tree x
, tree init
)
3812 return pushdecl_top_level_1 (x
, &init
, false);
3815 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3816 duplicates. The first list becomes the tail of the result.
3818 The algorithm is O(n^2). We could get this down to O(n log n) by
3819 doing a sort on the addresses of the functions, if that becomes
3823 merge_functions (tree s1
, tree s2
)
3825 for (; s2
; s2
= OVL_NEXT (s2
))
3827 tree fn2
= OVL_CURRENT (s2
);
3830 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3832 tree fn1
= OVL_CURRENT (fns1
);
3834 /* If the function from S2 is already in S1, there is no
3835 need to add it again. For `extern "C"' functions, we
3836 might have two FUNCTION_DECLs for the same function, in
3837 different namespaces, but let's leave them in in case
3838 they have different default arguments. */
3843 /* If we exhausted all of the functions in S1, FN2 is new. */
3845 s1
= build_overload (fn2
, s1
);
3850 /* Returns TRUE iff OLD and NEW are the same entity.
3852 3 [basic]/3: An entity is a value, object, reference, function,
3853 enumerator, type, class member, template, template specialization,
3854 namespace, parameter pack, or this.
3856 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
3857 in two different namespaces, and the declarations do not declare the
3858 same entity and do not declare functions, the use of the name is
3862 same_entity_p (tree one
, tree two
)
3868 if (TREE_CODE (one
) == TYPE_DECL
3869 && TREE_CODE (two
) == TYPE_DECL
3870 && same_type_p (TREE_TYPE (one
), TREE_TYPE (two
)))
3875 /* This should return an error not all definitions define functions.
3876 It is not an error if we find two functions with exactly the
3877 same signature, only if these are selected in overload resolution.
3878 old is the current set of bindings, new_binding the freshly-found binding.
3879 XXX Do we want to give *all* candidates in case of ambiguity?
3880 XXX In what way should I treat extern declarations?
3881 XXX I don't want to repeat the entire duplicate_decls here */
3884 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
3887 gcc_assert (old
!= NULL
);
3889 /* Copy the type. */
3890 type
= new_binding
->type
;
3891 if (LOOKUP_NAMESPACES_ONLY (flags
)
3892 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
3895 /* Copy the value. */
3896 val
= new_binding
->value
;
3899 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
3902 switch (TREE_CODE (val
))
3905 /* If we expect types or namespaces, and not templates,
3906 or this is not a template class. */
3907 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3908 && !DECL_CLASS_TEMPLATE_P (val
)))
3912 if (LOOKUP_NAMESPACES_ONLY (flags
)
3913 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
3916 case NAMESPACE_DECL
:
3917 if (LOOKUP_TYPES_ONLY (flags
))
3921 /* Ignore built-in functions that are still anticipated. */
3922 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3926 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3931 /* If val is hidden, shift down any class or enumeration name. */
3940 else if (val
&& !same_entity_p (val
, old
->value
))
3942 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3943 old
->value
= merge_functions (old
->value
, val
);
3946 old
->value
= tree_cons (NULL_TREE
, old
->value
,
3947 build_tree_list (NULL_TREE
, val
));
3948 TREE_TYPE (old
->value
) = error_mark_node
;
3954 else if (type
&& old
->type
!= type
)
3956 old
->type
= tree_cons (NULL_TREE
, old
->type
,
3957 build_tree_list (NULL_TREE
, type
));
3958 TREE_TYPE (old
->type
) = error_mark_node
;
3962 /* Return the declarations that are members of the namespace NS. */
3965 cp_namespace_decls (tree ns
)
3967 return NAMESPACE_LEVEL (ns
)->names
;
3970 /* Combine prefer_type and namespaces_only into flags. */
3973 lookup_flags (int prefer_type
, int namespaces_only
)
3975 if (namespaces_only
)
3976 return LOOKUP_PREFER_NAMESPACES
;
3977 if (prefer_type
> 1)
3978 return LOOKUP_PREFER_TYPES
;
3979 if (prefer_type
> 0)
3980 return LOOKUP_PREFER_BOTH
;
3984 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3985 ignore it or not. Subroutine of lookup_name_real and
3986 lookup_type_scope. */
3989 qualify_lookup (tree val
, int flags
)
3991 if (val
== NULL_TREE
)
3993 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3995 if ((flags
& LOOKUP_PREFER_TYPES
)
3996 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3998 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
4000 /* In unevaluated context, look past normal capture fields. */
4001 if (cp_unevaluated_operand
&& TREE_CODE (val
) == FIELD_DECL
4002 && DECL_NORMAL_CAPTURE_P (val
))
4004 /* None of the lookups that use qualify_lookup want the op() from the
4005 lambda; they want the one from the enclosing class. */
4006 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))
4011 /* Given a lookup that returned VAL, decide if we want to ignore it or
4012 not based on DECL_ANTICIPATED. */
4015 hidden_name_p (tree val
)
4018 && DECL_LANG_SPECIFIC (val
)
4019 && DECL_ANTICIPATED (val
))
4024 /* Remove any hidden friend functions from a possibly overloaded set
4028 remove_hidden_names (tree fns
)
4033 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
4035 else if (TREE_CODE (fns
) == OVERLOAD
)
4039 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4040 if (hidden_name_p (OVL_CURRENT (o
)))
4046 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4047 if (!hidden_name_p (OVL_CURRENT (o
)))
4048 n
= build_overload (OVL_CURRENT (o
), n
);
4056 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4057 lookup failed. Search through all available namespaces and print out
4058 possible candidates. */
4061 suggest_alternatives_for (location_t location
, tree name
)
4063 VEC(tree
,heap
) *candidates
= NULL
;
4064 VEC(tree
,heap
) *namespaces_to_search
= NULL
;
4065 int max_to_search
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
4070 VEC_safe_push (tree
, heap
, namespaces_to_search
, global_namespace
);
4072 while (!VEC_empty (tree
, namespaces_to_search
)
4073 && n_searched
< max_to_search
)
4075 tree scope
= VEC_pop (tree
, namespaces_to_search
);
4076 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4077 struct cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
4079 /* Look in this namespace. */
4080 qualified_lookup_using_namespace (name
, scope
, &binding
, 0);
4085 VEC_safe_push (tree
, heap
, candidates
, binding
.value
);
4087 /* Add child namespaces. */
4088 for (t
= level
->namespaces
; t
; t
= DECL_CHAIN (t
))
4089 VEC_safe_push (tree
, heap
, namespaces_to_search
, t
);
4092 /* If we stopped before we could examine all namespaces, inform the
4093 user. Do this even if we don't have any candidates, since there
4094 might be more candidates further down that we weren't able to
4096 if (n_searched
>= max_to_search
4097 && !VEC_empty (tree
, namespaces_to_search
))
4099 "maximum limit of %d namespaces searched for %qE",
4100 max_to_search
, name
);
4102 VEC_free (tree
, heap
, namespaces_to_search
);
4104 /* Nothing useful to report. */
4105 if (VEC_empty (tree
, candidates
))
4108 inform_n (location
, VEC_length (tree
, candidates
),
4109 "suggested alternative:",
4110 "suggested alternatives:");
4112 FOR_EACH_VEC_ELT (tree
, candidates
, ix
, t
)
4113 inform (location_of (t
), " %qE", t
);
4115 VEC_free (tree
, heap
, candidates
);
4118 /* Unscoped lookup of a global: iterate over current namespaces,
4119 considering using-directives. */
4122 unqualified_namespace_lookup_1 (tree name
, int flags
)
4124 tree initial
= current_decl_namespace ();
4125 tree scope
= initial
;
4127 struct cp_binding_level
*level
;
4128 tree val
= NULL_TREE
;
4130 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
4132 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4134 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4137 ambiguous_decl (&binding
, b
, flags
);
4139 /* Add all _DECLs seen through local using-directives. */
4140 for (level
= current_binding_level
;
4141 level
->kind
!= sk_namespace
;
4142 level
= level
->level_chain
)
4143 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
4145 /* Give up because of error. */
4146 return error_mark_node
;
4148 /* Add all _DECLs seen through global using-directives. */
4149 /* XXX local and global using lists should work equally. */
4153 if (!lookup_using_namespace (name
, &binding
,
4154 DECL_NAMESPACE_USING (siter
),
4156 /* Give up because of error. */
4157 return error_mark_node
;
4158 if (siter
== scope
) break;
4159 siter
= CP_DECL_CONTEXT (siter
);
4162 val
= binding
.value
;
4163 if (scope
== global_namespace
)
4169 /* Wrapper for unqualified_namespace_lookup_1. */
4172 unqualified_namespace_lookup (tree name
, int flags
)
4175 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4176 ret
= unqualified_namespace_lookup_1 (name
, flags
);
4177 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4181 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4182 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4185 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4186 declaration found. If no suitable declaration can be found,
4187 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4188 neither a class-type nor a namespace a diagnostic is issued. */
4191 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
4196 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
4198 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4200 flags
|= LOOKUP_COMPLAIN
;
4202 flags
|= LOOKUP_PREFER_TYPES
;
4203 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
4206 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
4207 t
= lookup_enumerator (scope
, name
);
4208 else if (is_class_type (scope
, complain
))
4209 t
= lookup_member (scope
, name
, 2, is_type_p
);
4212 return error_mark_node
;
4216 /* Subroutine of unqualified_namespace_lookup:
4217 Add the bindings of NAME in used namespaces to VAL.
4218 We are currently looking for names in namespace SCOPE, so we
4219 look through USINGS for using-directives of namespaces
4220 which have SCOPE as a common ancestor with the current scope.
4221 Returns false on errors. */
4224 lookup_using_namespace (tree name
, struct scope_binding
*val
,
4225 tree usings
, tree scope
, int flags
)
4228 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4229 /* Iterate over all used namespaces in current, searching for using
4230 directives of scope. */
4231 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
4232 if (TREE_VALUE (iter
) == scope
)
4234 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
4236 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
4237 /* Resolve ambiguities. */
4239 ambiguous_decl (val
, val1
, flags
);
4241 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4242 return val
->value
!= error_mark_node
;
4245 /* Returns true iff VEC contains TARGET. */
4248 tree_vec_contains (VEC(tree
,gc
)* vec
, tree target
)
4252 FOR_EACH_VEC_ELT (tree
,vec
,i
,elt
)
4259 Accepts the NAME to lookup and its qualifying SCOPE.
4260 Returns the name/type pair found into the cxx_binding *RESULT,
4261 or false on error. */
4264 qualified_lookup_using_namespace (tree name
, tree scope
,
4265 struct scope_binding
*result
, int flags
)
4267 /* Maintain a list of namespaces visited... */
4268 VEC(tree
,gc
) *seen
= NULL
;
4269 VEC(tree
,gc
) *seen_inline
= NULL
;
4270 /* ... and a list of namespace yet to see. */
4271 VEC(tree
,gc
) *todo
= NULL
;
4272 VEC(tree
,gc
) *todo_maybe
= NULL
;
4273 VEC(tree
,gc
) *todo_inline
= NULL
;
4275 timevar_start (TV_NAME_LOOKUP
);
4276 /* Look through namespace aliases. */
4277 scope
= ORIGINAL_NAMESPACE (scope
);
4279 /* Algorithm: Starting with SCOPE, walk through the set of used
4280 namespaces. For each used namespace, look through its inline
4281 namespace set for any bindings and usings. If no bindings are
4282 found, add any usings seen to the set of used namespaces. */
4283 VEC_safe_push (tree
, gc
, todo
, scope
);
4285 while (VEC_length (tree
, todo
))
4288 scope
= VEC_pop (tree
, todo
);
4289 if (tree_vec_contains (seen
, scope
))
4291 VEC_safe_push (tree
, gc
, seen
, scope
);
4292 VEC_safe_push (tree
, gc
, todo_inline
, scope
);
4295 while (VEC_length (tree
, todo_inline
))
4297 cxx_binding
*binding
;
4299 scope
= VEC_pop (tree
, todo_inline
);
4300 if (tree_vec_contains (seen_inline
, scope
))
4302 VEC_safe_push (tree
, gc
, seen_inline
, scope
);
4305 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4309 ambiguous_decl (result
, binding
, flags
);
4312 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
4313 usings
= TREE_CHAIN (usings
))
4314 if (!TREE_INDIRECT_USING (usings
))
4316 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
)))
4317 VEC_safe_push (tree
, gc
, todo_inline
, TREE_PURPOSE (usings
));
4319 VEC_safe_push (tree
, gc
, todo_maybe
, TREE_PURPOSE (usings
));
4324 VEC_truncate (tree
, todo_maybe
, 0);
4326 while (VEC_length (tree
, todo_maybe
))
4327 VEC_safe_push (tree
, gc
, todo
, VEC_pop (tree
, todo_maybe
));
4329 VEC_free (tree
,gc
,todo
);
4330 VEC_free (tree
,gc
,todo_maybe
);
4331 VEC_free (tree
,gc
,todo_inline
);
4332 VEC_free (tree
,gc
,seen
);
4333 VEC_free (tree
,gc
,seen_inline
);
4334 timevar_stop (TV_NAME_LOOKUP
);
4335 return result
->value
!= error_mark_node
;
4338 /* Subroutine of outer_binding.
4340 Returns TRUE if BINDING is a binding to a template parameter of
4341 SCOPE. In that case SCOPE is the scope of a primary template
4342 parameter -- in the sense of G++, i.e, a template that has its own
4345 Returns FALSE otherwise. */
4348 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
4353 if (!binding
|| !scope
)
4356 binding_value
= binding
->value
? binding
->value
: binding
->type
;
4359 && scope
->this_entity
4360 && get_template_info (scope
->this_entity
)
4361 && PRIMARY_TEMPLATE_P (TI_TEMPLATE
4362 (get_template_info (scope
->this_entity
)))
4363 && parameter_of_template_p (binding_value
,
4364 TI_TEMPLATE (get_template_info \
4365 (scope
->this_entity
))));
4368 /* Return the innermost non-namespace binding for NAME from a scope
4369 containing BINDING, or, if BINDING is NULL, the current scope.
4370 Please note that for a given template, the template parameters are
4371 considered to be in the scope containing the current scope.
4372 If CLASS_P is false, then class bindings are ignored. */
4375 outer_binding (tree name
,
4376 cxx_binding
*binding
,
4381 cxx_scope
*outer_scope
;
4385 scope
= binding
->scope
->level_chain
;
4386 outer
= binding
->previous
;
4390 scope
= current_binding_level
;
4391 outer
= IDENTIFIER_BINDING (name
);
4393 outer_scope
= outer
? outer
->scope
: NULL
;
4395 /* Because we create class bindings lazily, we might be missing a
4396 class binding for NAME. If there are any class binding levels
4397 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4398 declared, we must lookup NAME in those class scopes. */
4400 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4402 if (scope
->kind
== sk_class
)
4404 cxx_binding
*class_binding
;
4406 class_binding
= get_class_binding (name
, scope
);
4409 /* Thread this new class-scope binding onto the
4410 IDENTIFIER_BINDING list so that future lookups
4412 class_binding
->previous
= outer
;
4414 binding
->previous
= class_binding
;
4416 IDENTIFIER_BINDING (name
) = class_binding
;
4417 return class_binding
;
4420 /* If we are in a member template, the template parms of the member
4421 template are considered to be inside the scope of the containing
4422 class, but within G++ the class bindings are all pushed between the
4423 template parms and the function body. So if the outer binding is
4424 a template parm for the current scope, return it now rather than
4425 look for a class binding. */
4426 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4427 && binding_to_template_parms_of_scope_p (outer
, scope
))
4430 scope
= scope
->level_chain
;
4436 /* Return the innermost block-scope or class-scope value binding for
4437 NAME, or NULL_TREE if there is no such binding. */
4440 innermost_non_namespace_value (tree name
)
4442 cxx_binding
*binding
;
4443 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4444 return binding
? binding
->value
: NULL_TREE
;
4447 /* Look up NAME in the current binding level and its superiors in the
4448 namespace of variables, functions and typedefs. Return a ..._DECL
4449 node of some kind representing its definition if there is only one
4450 such declaration, or return a TREE_LIST with all the overloaded
4451 definitions if there are many, or return 0 if it is undefined.
4452 Hidden name, either friend declaration or built-in function, are
4455 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4456 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4457 Otherwise we prefer non-TYPE_DECLs.
4459 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4460 BLOCK_P is false, bindings in block scopes are ignored. */
4463 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4464 int namespaces_only
, int flags
)
4467 tree val
= NULL_TREE
;
4469 /* Conversion operators are handled specially because ordinary
4470 unqualified name lookup will not find template conversion
4472 if (IDENTIFIER_TYPENAME_P (name
))
4474 struct cp_binding_level
*level
;
4476 for (level
= current_binding_level
;
4477 level
&& level
->kind
!= sk_namespace
;
4478 level
= level
->level_chain
)
4483 /* A conversion operator can only be declared in a class
4485 if (level
->kind
!= sk_class
)
4488 /* Lookup the conversion operator in the class. */
4489 class_type
= level
->this_entity
;
4490 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4498 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4500 /* First, look in non-namespace scopes. */
4502 if (current_class_type
== NULL_TREE
)
4505 if (block_p
|| !nonclass
)
4506 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4508 iter
= outer_binding (name
, iter
, !nonclass
))
4512 /* Skip entities we don't want. */
4513 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4516 /* If this is the kind of thing we're looking for, we're done. */
4517 if (qualify_lookup (iter
->value
, flags
))
4518 binding
= iter
->value
;
4519 else if ((flags
& LOOKUP_PREFER_TYPES
)
4520 && qualify_lookup (iter
->type
, flags
))
4521 binding
= iter
->type
;
4523 binding
= NULL_TREE
;
4527 if (hidden_name_p (binding
))
4529 /* A non namespace-scope binding can only be hidden in the
4530 presence of a local class, due to friend declarations.
4532 In particular, consider:
4540 B* b; // error: B is hidden
4541 C* c; // OK, finds ::C
4544 B *b; // error: B is hidden
4545 C *c; // OK, finds ::C
4550 The standard says that "B" is a local class in "f"
4551 (but not nested within "A") -- but that name lookup
4552 for "B" does not find this declaration until it is
4553 declared directly with "f".
4559 If a friend declaration appears in a local class and
4560 the name specified is an unqualified name, a prior
4561 declaration is looked up without considering scopes
4562 that are outside the innermost enclosing non-class
4563 scope. For a friend function declaration, if there is
4564 no prior declaration, the program is ill-formed. For a
4565 friend class declaration, if there is no prior
4566 declaration, the class that is specified belongs to the
4567 innermost enclosing non-class scope, but if it is
4568 subsequently referenced, its name is not found by name
4569 lookup until a matching declaration is provided in the
4570 innermost enclosing nonclass scope.
4572 So just keep looking for a non-hidden binding.
4574 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4582 /* Now lookup in namespace scopes. */
4584 val
= unqualified_namespace_lookup (name
, flags
);
4586 /* If we have a single function from a using decl, pull it out. */
4587 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4588 val
= OVL_FUNCTION (val
);
4593 /* Wrapper for lookup_name_real_1. */
4596 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4597 int namespaces_only
, int flags
)
4600 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4601 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
4602 namespaces_only
, flags
);
4603 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4608 lookup_name_nonclass (tree name
)
4610 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4614 lookup_function_nonclass (tree name
, VEC(tree
,gc
) *args
, bool block_p
)
4617 lookup_arg_dependent (name
,
4618 lookup_name_real (name
, 0, 1, block_p
, 0,
4624 lookup_name (tree name
)
4626 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4630 lookup_name_prefer_type (tree name
, int prefer_type
)
4632 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
4633 0, LOOKUP_COMPLAIN
);
4636 /* Look up NAME for type used in elaborated name specifier in
4637 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4638 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4639 name, more scopes are checked if cleanup or template parameter
4640 scope is encountered.
4642 Unlike lookup_name_real, we make sure that NAME is actually
4643 declared in the desired scope, not from inheritance, nor using
4644 directive. For using declaration, there is DR138 still waiting
4645 to be resolved. Hidden name coming from an earlier friend
4646 declaration is also returned.
4648 A TYPE_DECL best matching the NAME is returned. Catching error
4649 and issuing diagnostics are caller's responsibility. */
4652 lookup_type_scope_1 (tree name
, tag_scope scope
)
4654 cxx_binding
*iter
= NULL
;
4655 tree val
= NULL_TREE
;
4657 /* Look in non-namespace scope first. */
4658 if (current_binding_level
->kind
!= sk_namespace
)
4659 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4660 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4662 /* Check if this is the kind of thing we're looking for.
4663 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4664 base class. For ITER->VALUE, we can simply use
4665 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4668 We check ITER->TYPE before ITER->VALUE in order to handle
4669 typedef struct C {} C;
4672 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4673 && (scope
!= ts_current
4674 || LOCAL_BINDING_P (iter
)
4675 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4677 else if ((scope
!= ts_current
4678 || !INHERITED_VALUE_BINDING_P (iter
))
4679 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4686 /* Look in namespace scope. */
4689 iter
= cxx_scope_find_binding_for_name
4690 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4694 /* If this is the kind of thing we're looking for, we're done. */
4695 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4697 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4703 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4704 and template parameter scopes. */
4707 struct cp_binding_level
*b
= current_binding_level
;
4710 if (iter
->scope
== b
)
4713 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
4714 || b
->kind
== sk_function_parms
)
4716 else if (b
->kind
== sk_class
4717 && scope
== ts_within_enclosing_non_class
)
4727 /* Wrapper for lookup_type_scope_1. */
4730 lookup_type_scope (tree name
, tag_scope scope
)
4733 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4734 ret
= lookup_type_scope_1 (name
, scope
);
4735 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4740 /* Similar to `lookup_name' but look only in the innermost non-class
4744 lookup_name_innermost_nonclass_level_1 (tree name
)
4746 struct cp_binding_level
*b
;
4749 b
= innermost_nonclass_level ();
4751 if (b
->kind
== sk_namespace
)
4753 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4755 /* extern "C" function() */
4756 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4759 else if (IDENTIFIER_BINDING (name
)
4760 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4762 cxx_binding
*binding
;
4763 binding
= IDENTIFIER_BINDING (name
);
4766 if (binding
->scope
== b
4767 && !(TREE_CODE (binding
->value
) == VAR_DECL
4768 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4769 return binding
->value
;
4771 if (b
->kind
== sk_cleanup
)
4781 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
4784 lookup_name_innermost_nonclass_level (tree name
)
4787 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4788 ret
= lookup_name_innermost_nonclass_level_1 (name
);
4789 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4794 /* Returns true iff DECL is a block-scope extern declaration of a function
4798 is_local_extern (tree decl
)
4800 cxx_binding
*binding
;
4802 /* For functions, this is easy. */
4803 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4804 return DECL_LOCAL_FUNCTION_P (decl
);
4806 if (TREE_CODE (decl
) != VAR_DECL
)
4808 if (!current_function_decl
)
4811 /* For variables, this is not easy. We need to look at the binding stack
4812 for the identifier to see whether the decl we have is a local. */
4813 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
4814 binding
&& binding
->scope
->kind
!= sk_namespace
;
4815 binding
= binding
->previous
)
4816 if (binding
->value
== decl
)
4817 return LOCAL_BINDING_P (binding
);
4822 /* Like lookup_name_innermost_nonclass_level, but for types. */
4825 lookup_type_current_level (tree name
)
4829 timevar_start (TV_NAME_LOOKUP
);
4830 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4832 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4833 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4835 struct cp_binding_level
*b
= current_binding_level
;
4838 if (purpose_member (name
, b
->type_shadowed
))
4840 t
= REAL_IDENTIFIER_TYPE_VALUE (name
);
4843 if (b
->kind
== sk_cleanup
)
4850 timevar_stop (TV_NAME_LOOKUP
);
4854 /* [basic.lookup.koenig] */
4855 /* A nonzero return value in the functions below indicates an error. */
4861 VEC(tree
,gc
) *namespaces
;
4862 VEC(tree
,gc
) *classes
;
4866 static bool arg_assoc (struct arg_lookup
*, tree
);
4867 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4868 static bool arg_assoc_args_vec (struct arg_lookup
*, VEC(tree
,gc
) *);
4869 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4870 static bool add_function (struct arg_lookup
*, tree
);
4871 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4872 static bool arg_assoc_class_only (struct arg_lookup
*, tree
);
4873 static bool arg_assoc_bases (struct arg_lookup
*, tree
);
4874 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4875 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4877 /* Add a function to the lookup structure.
4878 Returns true on error. */
4881 add_function (struct arg_lookup
*k
, tree fn
)
4883 /* We used to check here to see if the function was already in the list,
4884 but that's O(n^2), which is just too expensive for function lookup.
4885 Now we deal with the occasional duplicate in joust. In doing this, we
4886 assume that the number of duplicates will be small compared to the
4887 total number of functions being compared, which should usually be the
4890 if (!is_overloaded_fn (fn
))
4891 /* All names except those of (possibly overloaded) functions and
4892 function templates are ignored. */;
4893 else if (!k
->functions
)
4895 else if (fn
== k
->functions
)
4899 k
->functions
= build_overload (fn
, k
->functions
);
4900 if (TREE_CODE (k
->functions
) == OVERLOAD
)
4901 OVL_ARG_DEPENDENT (k
->functions
) = true;
4907 /* Returns true iff CURRENT has declared itself to be an associated
4908 namespace of SCOPE via a strong using-directive (or transitive chain
4909 thereof). Both are namespaces. */
4912 is_associated_namespace (tree current
, tree scope
)
4914 VEC(tree
,gc
) *seen
= make_tree_vector ();
4915 VEC(tree
,gc
) *todo
= make_tree_vector ();
4921 if (scope
== current
)
4926 VEC_safe_push (tree
, gc
, seen
, scope
);
4927 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4928 if (!vec_member (TREE_PURPOSE (t
), seen
))
4929 VEC_safe_push (tree
, gc
, todo
, TREE_PURPOSE (t
));
4930 if (!VEC_empty (tree
, todo
))
4932 scope
= VEC_last (tree
, todo
);
4933 VEC_pop (tree
, todo
);
4942 release_tree_vector (seen
);
4943 release_tree_vector (todo
);
4948 /* Add functions of a namespace to the lookup structure.
4949 Returns true on error. */
4952 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4956 if (vec_member (scope
, k
->namespaces
))
4958 VEC_safe_push (tree
, gc
, k
->namespaces
, scope
);
4960 /* Check out our super-users. */
4961 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4962 value
= TREE_CHAIN (value
))
4963 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4966 /* Also look down into inline namespaces. */
4967 for (value
= DECL_NAMESPACE_USING (scope
); value
;
4968 value
= TREE_CHAIN (value
))
4969 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
4970 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4973 value
= namespace_binding (k
->name
, scope
);
4977 for (; value
; value
= OVL_NEXT (value
))
4979 /* We don't want to find arbitrary hidden functions via argument
4980 dependent lookup. We only want to find friends of associated
4981 classes, which we'll do via arg_assoc_class. */
4982 if (hidden_name_p (OVL_CURRENT (value
)))
4985 if (add_function (k
, OVL_CURRENT (value
)))
4992 /* Adds everything associated with a template argument to the lookup
4993 structure. Returns true on error. */
4996 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4998 /* [basic.lookup.koenig]
5000 If T is a template-id, its associated namespaces and classes are
5001 ... the namespaces and classes associated with the types of the
5002 template arguments provided for template type parameters
5003 (excluding template template parameters); the namespaces in which
5004 any template template arguments are defined; and the classes in
5005 which any member templates used as template template arguments
5006 are defined. [Note: non-type template arguments do not
5007 contribute to the set of associated namespaces. ] */
5009 /* Consider first template template arguments. */
5010 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
5011 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
5013 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
5015 tree ctx
= CP_DECL_CONTEXT (arg
);
5017 /* It's not a member template. */
5018 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
5019 return arg_assoc_namespace (k
, ctx
);
5020 /* Otherwise, it must be member template. */
5022 return arg_assoc_class_only (k
, ctx
);
5024 /* It's an argument pack; handle it recursively. */
5025 else if (ARGUMENT_PACK_P (arg
))
5027 tree args
= ARGUMENT_PACK_ARGS (arg
);
5028 int i
, len
= TREE_VEC_LENGTH (args
);
5029 for (i
= 0; i
< len
; ++i
)
5030 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
5035 /* It's not a template template argument, but it is a type template
5037 else if (TYPE_P (arg
))
5038 return arg_assoc_type (k
, arg
);
5039 /* It's a non-type template argument. */
5044 /* Adds the class and its friends to the lookup structure.
5045 Returns true on error. */
5048 arg_assoc_class_only (struct arg_lookup
*k
, tree type
)
5050 tree list
, friends
, context
;
5052 /* Backend-built structures, such as __builtin_va_list, aren't
5053 affected by all this. */
5054 if (!CLASS_TYPE_P (type
))
5057 context
= decl_namespace_context (type
);
5058 if (arg_assoc_namespace (k
, context
))
5061 complete_type (type
);
5063 /* Process friends. */
5064 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
5065 list
= TREE_CHAIN (list
))
5066 if (k
->name
== FRIEND_NAME (list
))
5067 for (friends
= FRIEND_DECLS (list
); friends
;
5068 friends
= TREE_CHAIN (friends
))
5070 tree fn
= TREE_VALUE (friends
);
5072 /* Only interested in global functions with potentially hidden
5073 (i.e. unqualified) declarations. */
5074 if (CP_DECL_CONTEXT (fn
) != context
)
5076 /* Template specializations are never found by name lookup.
5077 (Templates themselves can be found, but not template
5078 specializations.) */
5079 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
5081 if (add_function (k
, fn
))
5088 /* Adds the class and its bases to the lookup structure.
5089 Returns true on error. */
5092 arg_assoc_bases (struct arg_lookup
*k
, tree type
)
5094 if (arg_assoc_class_only (k
, type
))
5097 if (TYPE_BINFO (type
))
5099 /* Process baseclasses. */
5100 tree binfo
, base_binfo
;
5103 for (binfo
= TYPE_BINFO (type
), i
= 0;
5104 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5105 if (arg_assoc_bases (k
, BINFO_TYPE (base_binfo
)))
5112 /* Adds everything associated with a class argument type to the lookup
5113 structure. Returns true on error.
5115 If T is a class type (including unions), its associated classes are: the
5116 class itself; the class of which it is a member, if any; and its direct
5117 and indirect base classes. Its associated namespaces are the namespaces
5118 of which its associated classes are members. Furthermore, if T is a
5119 class template specialization, its associated namespaces and classes
5120 also include: the namespaces and classes associated with the types of
5121 the template arguments provided for template type parameters (excluding
5122 template template parameters); the namespaces of which any template
5123 template arguments are members; and the classes of which any member
5124 templates used as template template arguments are members. [ Note:
5125 non-type template arguments do not contribute to the set of associated
5126 namespaces. --end note] */
5129 arg_assoc_class (struct arg_lookup
*k
, tree type
)
5134 /* Backend build structures, such as __builtin_va_list, aren't
5135 affected by all this. */
5136 if (!CLASS_TYPE_P (type
))
5139 if (vec_member (type
, k
->classes
))
5141 VEC_safe_push (tree
, gc
, k
->classes
, type
);
5143 if (TYPE_CLASS_SCOPE_P (type
)
5144 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5147 if (arg_assoc_bases (k
, type
))
5150 /* Process template arguments. */
5151 if (CLASSTYPE_TEMPLATE_INFO (type
)
5152 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
5154 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
5155 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
5156 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
)))
5163 /* Adds everything associated with a given type.
5164 Returns 1 on error. */
5167 arg_assoc_type (struct arg_lookup
*k
, tree type
)
5169 /* As we do not get the type of non-type dependent expressions
5170 right, we can end up with such things without a type. */
5174 if (TYPE_PTRMEM_P (type
))
5176 /* Pointer to member: associate class type and value type. */
5177 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
5179 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
5181 else switch (TREE_CODE (type
))
5191 case FIXED_POINT_TYPE
:
5196 if (TYPE_PTRMEMFUNC_P (type
))
5197 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
5199 return arg_assoc_class (k
, type
);
5201 case REFERENCE_TYPE
:
5203 return arg_assoc_type (k
, TREE_TYPE (type
));
5205 if (TYPE_CLASS_SCOPE_P (type
)
5206 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5208 return arg_assoc_namespace (k
, decl_namespace_context (type
));
5210 /* The basetype is referenced in the first arg type, so just
5213 /* Associate the parameter types. */
5214 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
5216 /* Associate the return type. */
5217 return arg_assoc_type (k
, TREE_TYPE (type
));
5218 case TEMPLATE_TYPE_PARM
:
5219 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5224 gcc_assert (type
== unknown_type_node
5225 || type
== init_list_type_node
);
5227 case TYPE_PACK_EXPANSION
:
5228 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
5236 /* Adds everything associated with arguments. Returns true on error. */
5239 arg_assoc_args (struct arg_lookup
*k
, tree args
)
5241 for (; args
; args
= TREE_CHAIN (args
))
5242 if (arg_assoc (k
, TREE_VALUE (args
)))
5247 /* Adds everything associated with an argument vector. Returns true
5251 arg_assoc_args_vec (struct arg_lookup
*k
, VEC(tree
,gc
) *args
)
5256 FOR_EACH_VEC_ELT (tree
, args
, ix
, arg
)
5257 if (arg_assoc (k
, arg
))
5262 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5265 arg_assoc (struct arg_lookup
*k
, tree n
)
5267 if (n
== error_mark_node
)
5271 return arg_assoc_type (k
, n
);
5273 if (! type_unknown_p (n
))
5274 return arg_assoc_type (k
, TREE_TYPE (n
));
5276 if (TREE_CODE (n
) == ADDR_EXPR
)
5277 n
= TREE_OPERAND (n
, 0);
5278 if (TREE_CODE (n
) == COMPONENT_REF
)
5279 n
= TREE_OPERAND (n
, 1);
5280 if (TREE_CODE (n
) == OFFSET_REF
)
5281 n
= TREE_OPERAND (n
, 1);
5282 while (TREE_CODE (n
) == TREE_LIST
)
5284 if (TREE_CODE (n
) == BASELINK
)
5285 n
= BASELINK_FUNCTIONS (n
);
5287 if (TREE_CODE (n
) == FUNCTION_DECL
)
5288 return arg_assoc_type (k
, TREE_TYPE (n
));
5289 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
5291 /* The working paper doesn't currently say how to handle template-id
5292 arguments. The sensible thing would seem to be to handle the list
5293 of template candidates like a normal overload set, and handle the
5294 template arguments like we do for class template
5296 tree templ
= TREE_OPERAND (n
, 0);
5297 tree args
= TREE_OPERAND (n
, 1);
5300 /* First the templates. */
5301 if (arg_assoc (k
, templ
))
5304 /* Now the arguments. */
5306 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
5307 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
5310 else if (TREE_CODE (n
) == OVERLOAD
)
5312 for (; n
; n
= OVL_NEXT (n
))
5313 if (arg_assoc_type (k
, TREE_TYPE (OVL_CURRENT (n
))))
5320 /* Performs Koenig lookup depending on arguments, where fns
5321 are the functions found in normal lookup. */
5324 lookup_arg_dependent_1 (tree name
, tree fns
, VEC(tree
,gc
) *args
,
5327 struct arg_lookup k
;
5329 /* Remove any hidden friend functions from the list of functions
5330 found so far. They will be added back by arg_assoc_class as
5332 fns
= remove_hidden_names (fns
);
5337 k
.classes
= make_tree_vector ();
5339 /* We previously performed an optimization here by setting
5340 NAMESPACES to the current namespace when it was safe. However, DR
5341 164 says that namespaces that were already searched in the first
5342 stage of template processing are searched again (potentially
5343 picking up later definitions) in the second stage. */
5344 k
.namespaces
= make_tree_vector ();
5347 arg_assoc_namespace (&k
, std_node
);
5348 arg_assoc_args_vec (&k
, args
);
5353 && TREE_CODE (fns
) != VAR_DECL
5354 && !is_overloaded_fn (fns
))
5356 error ("argument dependent lookup finds %q+D", fns
);
5357 error (" in call to %qD", name
);
5358 fns
= error_mark_node
;
5361 release_tree_vector (k
.classes
);
5362 release_tree_vector (k
.namespaces
);
5367 /* Wrapper for lookup_arg_dependent_1. */
5370 lookup_arg_dependent (tree name
, tree fns
, VEC(tree
,gc
) *args
,
5374 timevar_start (TV_NAME_LOOKUP
);
5375 ret
= lookup_arg_dependent_1 (name
, fns
, args
, include_std
);
5376 timevar_stop (TV_NAME_LOOKUP
);
5381 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5382 changed (i.e. there was already a directive), or the fresh
5383 TREE_LIST otherwise. */
5386 push_using_directive_1 (tree used
)
5388 tree ud
= current_binding_level
->using_directives
;
5389 tree iter
, ancestor
;
5391 /* Check if we already have this. */
5392 if (purpose_member (used
, ud
) != NULL_TREE
)
5395 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
5396 ud
= current_binding_level
->using_directives
;
5397 ud
= tree_cons (used
, ancestor
, ud
);
5398 current_binding_level
->using_directives
= ud
;
5400 /* Recursively add all namespaces used. */
5401 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
5402 push_using_directive (TREE_PURPOSE (iter
));
5407 /* Wrapper for push_using_directive_1. */
5410 push_using_directive (tree used
)
5413 timevar_start (TV_NAME_LOOKUP
);
5414 ret
= push_using_directive_1 (used
);
5415 timevar_stop (TV_NAME_LOOKUP
);
5419 /* The type TYPE is being declared. If it is a class template, or a
5420 specialization of a class template, do any processing required and
5421 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5422 being declared a friend. B is the binding level at which this TYPE
5425 Returns the TYPE_DECL for TYPE, which may have been altered by this
5429 maybe_process_template_type_declaration (tree type
, int is_friend
,
5432 tree decl
= TYPE_NAME (type
);
5434 if (processing_template_parmlist
)
5435 /* You can't declare a new template type in a template parameter
5436 list. But, you can declare a non-template type:
5438 template <class A*> struct S;
5440 is a forward-declaration of `A'. */
5442 else if (b
->kind
== sk_namespace
5443 && current_binding_level
->kind
!= sk_namespace
)
5444 /* If this new type is being injected into a containing scope,
5445 then it's not a template type. */
5449 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5450 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5452 if (processing_template_decl
)
5454 /* This may change after the call to
5455 push_template_decl_real, but we want the original value. */
5456 tree name
= DECL_NAME (decl
);
5458 decl
= push_template_decl_real (decl
, is_friend
);
5459 if (decl
== error_mark_node
)
5460 return error_mark_node
;
5462 /* If the current binding level is the binding level for the
5463 template parameters (see the comment in
5464 begin_template_parm_list) and the enclosing level is a class
5465 scope, and we're not looking at a friend, push the
5466 declaration of the member class into the class scope. In the
5467 friend case, push_template_decl will already have put the
5468 friend into global scope, if appropriate. */
5469 if (TREE_CODE (type
) != ENUMERAL_TYPE
5470 && !is_friend
&& b
->kind
== sk_template_parms
5471 && b
->level_chain
->kind
== sk_class
)
5473 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5475 if (!COMPLETE_TYPE_P (current_class_type
))
5477 maybe_add_class_template_decl_list (current_class_type
,
5478 type
, /*friend_p=*/0);
5479 /* Put this UTD in the table of UTDs for the class. */
5480 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5481 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5482 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5484 binding_table_insert
5485 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5494 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5495 that the NAME is a class template, the tag is processed but not pushed.
5497 The pushed scope depend on the SCOPE parameter:
5498 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5500 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5501 non-template-parameter scope. This case is needed for forward
5503 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5504 TS_GLOBAL case except that names within template-parameter scopes
5505 are not pushed at all.
5507 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5510 pushtag_1 (tree name
, tree type
, tag_scope scope
)
5512 struct cp_binding_level
*b
;
5515 b
= current_binding_level
;
5516 while (/* Cleanup scopes are not scopes from the point of view of
5518 b
->kind
== sk_cleanup
5519 /* Neither are function parameter scopes. */
5520 || b
->kind
== sk_function_parms
5521 /* Neither are the scopes used to hold template parameters
5522 for an explicit specialization. For an ordinary template
5523 declaration, these scopes are not scopes from the point of
5524 view of the language. */
5525 || (b
->kind
== sk_template_parms
5526 && (b
->explicit_spec_p
|| scope
== ts_global
))
5527 || (b
->kind
== sk_class
5528 && (scope
!= ts_current
5529 /* We may be defining a new type in the initializer
5530 of a static member variable. We allow this when
5531 not pedantic, and it is particularly useful for
5532 type punning via an anonymous union. */
5533 || COMPLETE_TYPE_P (b
->this_entity
))))
5536 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5538 /* Do C++ gratuitous typedefing. */
5539 if (identifier_type_value_1 (name
) != type
)
5543 tree context
= TYPE_CONTEXT (type
);
5547 tree cs
= current_scope ();
5549 if (scope
== ts_current
5550 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
5552 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5553 /* When declaring a friend class of a local class, we want
5554 to inject the newly named class into the scope
5555 containing the local class, not the namespace
5557 context
= decl_function_context (get_type_decl (cs
));
5560 context
= current_namespace
;
5562 if (b
->kind
== sk_class
5563 || (b
->kind
== sk_template_parms
5564 && b
->level_chain
->kind
== sk_class
))
5567 if (current_lang_name
== lang_name_java
)
5568 TYPE_FOR_JAVA (type
) = 1;
5570 tdef
= create_implicit_typedef (name
, type
);
5571 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5572 if (scope
== ts_within_enclosing_non_class
)
5574 /* This is a friend. Make this TYPE_DECL node hidden from
5575 ordinary name lookup. Its corresponding TEMPLATE_DECL
5576 will be marked in push_template_decl_real. */
5577 retrofit_lang_decl (tdef
);
5578 DECL_ANTICIPATED (tdef
) = 1;
5579 DECL_FRIEND_P (tdef
) = 1;
5582 decl
= maybe_process_template_type_declaration
5583 (type
, scope
== ts_within_enclosing_non_class
, b
);
5584 if (decl
== error_mark_node
)
5587 if (b
->kind
== sk_class
)
5589 if (!TYPE_BEING_DEFINED (current_class_type
))
5590 return error_mark_node
;
5592 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5593 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5594 class. But if it's a member template class, we want
5595 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5597 finish_member_declaration (decl
);
5599 pushdecl_class_level (decl
);
5601 else if (b
->kind
!= sk_template_parms
)
5603 decl
= pushdecl_with_scope_1 (decl
, b
, /*is_friend=*/false);
5604 if (decl
== error_mark_node
)
5609 set_identifier_type_value_with_scope (name
, tdef
, b
);
5611 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5613 /* If this is a local class, keep track of it. We need this
5614 information for name-mangling, and so that it is possible to
5615 find all function definitions in a translation unit in a
5616 convenient way. (It's otherwise tricky to find a member
5617 function definition it's only pointed to from within a local
5619 if (TYPE_CONTEXT (type
)
5620 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
5621 VEC_safe_push (tree
, gc
, local_classes
, type
);
5623 if (b
->kind
== sk_class
5624 && !COMPLETE_TYPE_P (current_class_type
))
5626 maybe_add_class_template_decl_list (current_class_type
,
5627 type
, /*friend_p=*/0);
5629 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5630 CLASSTYPE_NESTED_UTDS (current_class_type
)
5631 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5633 binding_table_insert
5634 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5637 decl
= TYPE_NAME (type
);
5638 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
5640 /* Set type visibility now if this is a forward declaration. */
5641 TREE_PUBLIC (decl
) = 1;
5642 determine_visibility (decl
);
5647 /* Wrapper for pushtag_1. */
5650 pushtag (tree name
, tree type
, tag_scope scope
)
5653 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5654 ret
= pushtag_1 (name
, type
, scope
);
5655 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5659 /* Subroutines for reverting temporarily to top-level for instantiation
5660 of templates and such. We actually need to clear out the class- and
5661 local-value slots of all identifiers, so that only the global values
5662 are at all visible. Simply setting current_binding_level to the global
5663 scope isn't enough, because more binding levels may be pushed. */
5664 struct saved_scope
*scope_chain
;
5666 /* If ID has not already been marked, add an appropriate binding to
5670 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5672 cxx_saved_binding
*saved
;
5674 if (!id
|| !IDENTIFIER_BINDING (id
))
5677 if (IDENTIFIER_MARKED (id
))
5680 IDENTIFIER_MARKED (id
) = 1;
5682 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
5683 saved
->identifier
= id
;
5684 saved
->binding
= IDENTIFIER_BINDING (id
);
5685 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
5686 IDENTIFIER_BINDING (id
) = NULL
;
5690 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5694 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5695 for (t
= names
; t
; t
= TREE_CHAIN (t
))
5699 if (TREE_CODE (t
) == TREE_LIST
)
5700 id
= TREE_PURPOSE (t
);
5704 store_binding (id
, old_bindings
);
5706 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5709 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5710 objects, rather than a TREE_LIST. */
5713 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
5714 VEC(cxx_saved_binding
,gc
) **old_bindings
)
5717 cp_class_binding
*cb
;
5719 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5720 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
5721 store_binding (cb
->identifier
, old_bindings
);
5722 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5726 push_to_top_level (void)
5728 struct saved_scope
*s
;
5729 struct cp_binding_level
*b
;
5730 cxx_saved_binding
*sb
;
5734 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5735 s
= ggc_alloc_cleared_saved_scope ();
5737 b
= scope_chain
? current_binding_level
: 0;
5739 /* If we're in the middle of some function, save our state. */
5743 push_function_context ();
5748 if (scope_chain
&& previous_class_level
)
5749 store_class_bindings (previous_class_level
->class_shadowed
,
5752 /* Have to include the global scope, because class-scope decls
5753 aren't listed anywhere useful. */
5754 for (; b
; b
= b
->level_chain
)
5758 /* Template IDs are inserted into the global level. If they were
5759 inserted into namespace level, finish_file wouldn't find them
5760 when doing pending instantiations. Therefore, don't stop at
5761 namespace level, but continue until :: . */
5762 if (global_scope_p (b
))
5765 store_bindings (b
->names
, &s
->old_bindings
);
5766 /* We also need to check class_shadowed to save class-level type
5767 bindings, since pushclass doesn't fill in b->names. */
5768 if (b
->kind
== sk_class
)
5769 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
5771 /* Unwind type-value slots back to top level. */
5772 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
5773 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
5776 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, sb
)
5777 IDENTIFIER_MARKED (sb
->identifier
) = 0;
5779 s
->prev
= scope_chain
;
5781 s
->need_pop_function_context
= need_pop
;
5782 s
->function_decl
= current_function_decl
;
5783 s
->unevaluated_operand
= cp_unevaluated_operand
;
5784 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
5787 current_function_decl
= NULL_TREE
;
5788 current_lang_base
= VEC_alloc (tree
, gc
, 10);
5789 current_lang_name
= lang_name_cplusplus
;
5790 current_namespace
= global_namespace
;
5791 push_class_stack ();
5792 cp_unevaluated_operand
= 0;
5793 c_inhibit_evaluation_warnings
= 0;
5794 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5798 pop_from_top_level_1 (void)
5800 struct saved_scope
*s
= scope_chain
;
5801 cxx_saved_binding
*saved
;
5804 /* Clear out class-level bindings cache. */
5805 if (previous_class_level
)
5806 invalidate_class_lookup_cache ();
5809 current_lang_base
= 0;
5811 scope_chain
= s
->prev
;
5812 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, saved
)
5814 tree id
= saved
->identifier
;
5816 IDENTIFIER_BINDING (id
) = saved
->binding
;
5817 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
5820 /* If we were in the middle of compiling a function, restore our
5822 if (s
->need_pop_function_context
)
5823 pop_function_context ();
5824 current_function_decl
= s
->function_decl
;
5825 cp_unevaluated_operand
= s
->unevaluated_operand
;
5826 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
5829 /* Wrapper for pop_from_top_level_1. */
5832 pop_from_top_level (void)
5834 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5835 pop_from_top_level_1 ();
5836 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5840 /* Pop off extraneous binding levels left over due to syntax errors.
5842 We don't pop past namespaces, as they might be valid. */
5845 pop_everything (void)
5847 if (ENABLE_SCOPE_CHECKING
)
5848 verbatim ("XXX entering pop_everything ()\n");
5849 while (!toplevel_bindings_p ())
5851 if (current_binding_level
->kind
== sk_class
)
5852 pop_nested_class ();
5856 if (ENABLE_SCOPE_CHECKING
)
5857 verbatim ("XXX leaving pop_everything ()\n");
5860 /* Emit debugging information for using declarations and directives.
5861 If input tree is overloaded fn then emit debug info for all
5865 cp_emit_debug_info_for_using (tree t
, tree context
)
5867 /* Don't try to emit any debug information if we have errors. */
5871 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5872 of a builtin function. */
5873 if (TREE_CODE (t
) == FUNCTION_DECL
5874 && DECL_EXTERNAL (t
)
5875 && DECL_BUILT_IN (t
))
5878 /* Do not supply context to imported_module_or_decl, if
5879 it is a global namespace. */
5880 if (context
== global_namespace
)
5881 context
= NULL_TREE
;
5884 t
= BASELINK_FUNCTIONS (t
);
5886 /* FIXME: Handle TEMPLATE_DECLs. */
5887 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
5888 if (TREE_CODE (t
) != TEMPLATE_DECL
)
5890 if (building_stmt_tree ())
5891 add_stmt (build_stmt (input_location
, USING_STMT
, t
));
5893 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
5897 #include "gt-cp-name-lookup.h"