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"
32 #include "diagnostic-core.h"
34 #include "c-family/c-pragma.h"
36 /* The bindings for a particular name in a particular scope. */
38 struct scope_binding
{
42 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
44 static cxx_scope
*innermost_nonclass_level (void);
45 static cxx_binding
*binding_for_name (cxx_scope
*, tree
);
46 static tree
push_overloaded_decl (tree
, int, bool);
47 static bool lookup_using_namespace (tree
, struct scope_binding
*, tree
,
49 static bool qualified_lookup_using_namespace (tree
, tree
,
50 struct scope_binding
*, int);
51 static tree
lookup_type_current_level (tree
);
52 static tree
push_using_directive (tree
);
53 static cxx_binding
* lookup_extern_c_fun_binding_in_all_ns (tree
);
55 /* The :: namespace. */
57 tree global_namespace
;
59 /* The name of the anonymous namespace, throughout this translation
61 static GTY(()) tree anonymous_namespace_name
;
63 /* Initialize anonymous_namespace_name if necessary, and return it. */
66 get_anonymous_namespace_name (void)
68 if (!anonymous_namespace_name
)
70 /* The anonymous namespace has to have a unique name
71 if typeinfo objects are being compared by name. */
72 if (! flag_weak
|| ! SUPPORTS_ONE_ONLY
)
73 anonymous_namespace_name
= get_file_function_name ("N");
75 /* The demangler expects anonymous namespaces to be called
76 something starting with '_GLOBAL__N_'. */
77 anonymous_namespace_name
= get_identifier ("_GLOBAL__N_1");
79 return anonymous_namespace_name
;
82 /* Compute the chain index of a binding_entry given the HASH value of its
83 name and the total COUNT of chains. COUNT is assumed to be a power
86 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
88 /* A free list of "binding_entry"s awaiting for re-use. */
90 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
92 /* Create a binding_entry object for (NAME, TYPE). */
94 static inline binding_entry
95 binding_entry_make (tree name
, tree type
)
99 if (free_binding_entry
)
101 entry
= free_binding_entry
;
102 free_binding_entry
= entry
->chain
;
105 entry
= ggc_alloc_binding_entry_s ();
114 /* Put ENTRY back on the free list. */
117 binding_entry_free (binding_entry entry
)
121 entry
->chain
= free_binding_entry
;
122 free_binding_entry
= entry
;
126 /* The datatype used to implement the mapping from names to types at
128 struct GTY(()) binding_table_s
{
129 /* Array of chains of "binding_entry"s */
130 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
132 /* The number of chains in this table. This is the length of the
133 member "chain" considered as an array. */
136 /* Number of "binding_entry"s in this table. */
140 /* Construct TABLE with an initial CHAIN_COUNT. */
143 binding_table_construct (binding_table table
, size_t chain_count
)
145 table
->chain_count
= chain_count
;
146 table
->entry_count
= 0;
147 table
->chain
= ggc_alloc_cleared_vec_binding_entry (table
->chain_count
);
150 /* Make TABLE's entries ready for reuse. */
153 binding_table_free (binding_table table
)
161 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
163 binding_entry temp
= table
->chain
[i
];
166 binding_entry entry
= temp
;
168 binding_entry_free (entry
);
170 table
->chain
[i
] = NULL
;
172 table
->entry_count
= 0;
176 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
178 static inline binding_table
179 binding_table_new (size_t chain_count
)
181 binding_table table
= ggc_alloc_binding_table_s ();
183 binding_table_construct (table
, chain_count
);
187 /* Expand TABLE to twice its current chain_count. */
190 binding_table_expand (binding_table table
)
192 const size_t old_chain_count
= table
->chain_count
;
193 const size_t old_entry_count
= table
->entry_count
;
194 const size_t new_chain_count
= 2 * old_chain_count
;
195 binding_entry
*old_chains
= table
->chain
;
198 binding_table_construct (table
, new_chain_count
);
199 for (i
= 0; i
< old_chain_count
; ++i
)
201 binding_entry entry
= old_chains
[i
];
202 for (; entry
!= NULL
; entry
= old_chains
[i
])
204 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
205 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
207 old_chains
[i
] = entry
->chain
;
208 entry
->chain
= table
->chain
[j
];
209 table
->chain
[j
] = entry
;
212 table
->entry_count
= old_entry_count
;
215 /* Insert a binding for NAME to TYPE into TABLE. */
218 binding_table_insert (binding_table table
, tree name
, tree type
)
220 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
221 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
222 binding_entry entry
= binding_entry_make (name
, type
);
224 entry
->chain
= table
->chain
[i
];
225 table
->chain
[i
] = entry
;
226 ++table
->entry_count
;
228 if (3 * table
->chain_count
< 5 * table
->entry_count
)
229 binding_table_expand (table
);
232 /* Return the binding_entry, if any, that maps NAME. */
235 binding_table_find (binding_table table
, tree name
)
237 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
238 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
240 while (entry
!= NULL
&& entry
->name
!= name
)
241 entry
= entry
->chain
;
246 /* Apply PROC -- with DATA -- to all entries in TABLE. */
249 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
251 const size_t chain_count
= table
->chain_count
;
254 for (i
= 0; i
< chain_count
; ++i
)
256 binding_entry entry
= table
->chain
[i
];
257 for (; entry
!= NULL
; entry
= entry
->chain
)
262 #ifndef ENABLE_SCOPE_CHECKING
263 # define ENABLE_SCOPE_CHECKING 0
265 # define ENABLE_SCOPE_CHECKING 1
268 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
270 static GTY((deletable
)) cxx_binding
*free_bindings
;
272 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
276 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
278 binding
->value
= value
;
279 binding
->type
= type
;
280 binding
->previous
= NULL
;
283 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
286 cxx_binding_make (tree value
, tree type
)
288 cxx_binding
*binding
;
291 binding
= free_bindings
;
292 free_bindings
= binding
->previous
;
295 binding
= ggc_alloc_cxx_binding ();
297 cxx_binding_init (binding
, value
, type
);
302 /* Put BINDING back on the free list. */
305 cxx_binding_free (cxx_binding
*binding
)
307 binding
->scope
= NULL
;
308 binding
->previous
= free_bindings
;
309 free_bindings
= binding
;
312 /* Create a new binding for NAME (with the indicated VALUE and TYPE
313 bindings) in the class scope indicated by SCOPE. */
316 new_class_binding (tree name
, tree value
, tree type
, cxx_scope
*scope
)
318 cp_class_binding
*cb
;
319 cxx_binding
*binding
;
321 if (VEC_length (cp_class_binding
, scope
->class_shadowed
))
323 cp_class_binding
*old_base
;
324 old_base
= VEC_index (cp_class_binding
, scope
->class_shadowed
, 0);
325 if (VEC_reserve (cp_class_binding
, gc
, scope
->class_shadowed
, 1))
327 /* Fixup the current bindings, as they might have moved. */
331 VEC_iterate (cp_class_binding
, scope
->class_shadowed
, i
, cb
);
335 b
= &IDENTIFIER_BINDING (cb
->identifier
);
336 while (*b
!= &old_base
[i
].base
)
337 b
= &((*b
)->previous
);
341 cb
= VEC_quick_push (cp_class_binding
, scope
->class_shadowed
, NULL
);
344 cb
= VEC_safe_push (cp_class_binding
, gc
, scope
->class_shadowed
, NULL
);
346 cb
->identifier
= name
;
348 binding
->scope
= scope
;
349 cxx_binding_init (binding
, value
, type
);
353 /* Make DECL the innermost binding for ID. The LEVEL is the binding
354 level at which this declaration is being bound. */
357 push_binding (tree id
, tree decl
, cxx_scope
* level
)
359 cxx_binding
*binding
;
361 if (level
!= class_binding_level
)
363 binding
= cxx_binding_make (decl
, NULL_TREE
);
364 binding
->scope
= level
;
367 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
369 /* Now, fill in the binding information. */
370 binding
->previous
= IDENTIFIER_BINDING (id
);
371 INHERITED_VALUE_BINDING_P (binding
) = 0;
372 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
374 /* And put it on the front of the list of bindings for ID. */
375 IDENTIFIER_BINDING (id
) = binding
;
378 /* Remove the binding for DECL which should be the innermost binding
382 pop_binding (tree id
, tree decl
)
384 cxx_binding
*binding
;
387 /* It's easiest to write the loops that call this function without
388 checking whether or not the entities involved have names. We
389 get here for such an entity. */
392 /* Get the innermost binding for ID. */
393 binding
= IDENTIFIER_BINDING (id
);
395 /* The name should be bound. */
396 gcc_assert (binding
!= NULL
);
398 /* The DECL will be either the ordinary binding or the type
399 binding for this identifier. Remove that binding. */
400 if (binding
->value
== decl
)
401 binding
->value
= NULL_TREE
;
404 gcc_assert (binding
->type
== decl
);
405 binding
->type
= NULL_TREE
;
408 if (!binding
->value
&& !binding
->type
)
410 /* We're completely done with the innermost binding for this
411 identifier. Unhook it from the list of bindings. */
412 IDENTIFIER_BINDING (id
) = binding
->previous
;
414 /* Add it to the free list. */
415 cxx_binding_free (binding
);
419 /* BINDING records an existing declaration for a name in the current scope.
420 But, DECL is another declaration for that same identifier in the
421 same scope. This is the `struct stat' hack whereby a non-typedef
422 class name or enum-name can be bound at the same level as some other
426 A class name (9.1) or enumeration name (7.2) can be hidden by the
427 name of an object, function, or enumerator declared in the same scope.
428 If a class or enumeration name and an object, function, or enumerator
429 are declared in the same scope (in any order) with the same name, the
430 class or enumeration name is hidden wherever the object, function, or
431 enumerator name is visible.
433 It's the responsibility of the caller to check that
434 inserting this name is valid here. Returns nonzero if the new binding
438 supplement_binding (cxx_binding
*binding
, tree decl
)
440 tree bval
= binding
->value
;
443 timevar_push (TV_NAME_LOOKUP
);
444 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
445 /* The new name is the type name. */
446 binding
->type
= decl
;
447 else if (/* BVAL is null when push_class_level_binding moves an
448 inherited type-binding out of the way to make room for a
449 new value binding. */
451 /* BVAL is error_mark_node when DECL's name has been used
452 in a non-class scope prior declaration. In that case,
453 we should have already issued a diagnostic; for graceful
454 error recovery purpose, pretend this was the intended
455 declaration for that name. */
456 || bval
== error_mark_node
457 /* If BVAL is anticipated but has not yet been declared,
458 pretend it is not there at all. */
459 || (TREE_CODE (bval
) == FUNCTION_DECL
460 && DECL_ANTICIPATED (bval
)
461 && !DECL_HIDDEN_FRIEND_P (bval
)))
462 binding
->value
= decl
;
463 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
465 /* The old binding was a type name. It was placed in
466 VALUE field because it was thought, at the point it was
467 declared, to be the only entity with such a name. Move the
468 type name into the type slot; it is now hidden by the new
470 binding
->type
= bval
;
471 binding
->value
= decl
;
472 binding
->value_is_inherited
= false;
474 else if (TREE_CODE (bval
) == TYPE_DECL
475 && TREE_CODE (decl
) == TYPE_DECL
476 && DECL_NAME (decl
) == DECL_NAME (bval
)
477 && binding
->scope
->kind
!= sk_class
478 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
479 /* If either type involves template parameters, we must
480 wait until instantiation. */
481 || uses_template_parms (TREE_TYPE (decl
))
482 || uses_template_parms (TREE_TYPE (bval
))))
483 /* We have two typedef-names, both naming the same type to have
484 the same name. In general, this is OK because of:
488 In a given scope, a typedef specifier can be used to redefine
489 the name of any type declared in that scope to refer to the
490 type to which it already refers.
492 However, in class scopes, this rule does not apply due to the
493 stricter language in [class.mem] prohibiting redeclarations of
496 /* There can be two block-scope declarations of the same variable,
497 so long as they are `extern' declarations. However, there cannot
498 be two declarations of the same static data member:
502 A member shall not be declared twice in the
503 member-specification. */
504 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
505 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
506 && !DECL_CLASS_SCOPE_P (decl
))
508 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
511 else if (TREE_CODE (decl
) == NAMESPACE_DECL
512 && TREE_CODE (bval
) == NAMESPACE_DECL
513 && DECL_NAMESPACE_ALIAS (decl
)
514 && DECL_NAMESPACE_ALIAS (bval
)
515 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
518 In a declarative region, a namespace-alias-definition can be
519 used to redefine a namespace-alias declared in that declarative
520 region to refer only to the namespace to which it already
525 error ("declaration of %q#D", decl
);
526 error ("conflicts with previous declaration %q+#D", bval
);
530 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
533 /* Add DECL to the list of things declared in B. */
536 add_decl_to_level (tree decl
, cxx_scope
*b
)
538 /* We used to record virtual tables as if they were ordinary
539 variables, but no longer do so. */
540 gcc_assert (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
)));
542 if (TREE_CODE (decl
) == NAMESPACE_DECL
543 && !DECL_NAMESPACE_ALIAS (decl
))
545 TREE_CHAIN (decl
) = b
->namespaces
;
546 b
->namespaces
= decl
;
550 /* We build up the list in reverse order, and reverse it later if
552 TREE_CHAIN (decl
) = b
->names
;
556 /* If appropriate, add decl to separate list of statics. We
557 include extern variables because they might turn out to be
558 static later. It's OK for this list to contain a few false
560 if (b
->kind
== sk_namespace
)
561 if ((TREE_CODE (decl
) == VAR_DECL
562 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
563 || (TREE_CODE (decl
) == FUNCTION_DECL
564 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
565 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
569 /* Record a decl-node X as belonging to the current lexical scope.
570 Check for errors (such as an incompatible declaration for the same
571 name already seen in the same scope). IS_FRIEND is true if X is
572 declared as a friend.
574 Returns either X or an old decl for the same name.
575 If an old decl is returned, it may have been smashed
576 to agree with what X says. */
579 pushdecl_maybe_friend (tree x
, bool is_friend
)
583 int need_new_binding
;
585 timevar_push (TV_NAME_LOOKUP
);
587 if (x
== error_mark_node
)
588 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
590 need_new_binding
= 1;
592 if (DECL_TEMPLATE_PARM_P (x
))
593 /* Template parameters have no context; they are not X::T even
594 when declared within a class or namespace. */
598 if (current_function_decl
&& x
!= current_function_decl
599 /* A local declaration for a function doesn't constitute
601 && TREE_CODE (x
) != FUNCTION_DECL
602 /* A local declaration for an `extern' variable is in the
603 scope of the current namespace, not the current
605 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
606 /* When parsing the parameter list of a function declarator,
607 don't set DECL_CONTEXT to an enclosing function. When we
608 push the PARM_DECLs in order to process the function body,
609 current_binding_level->this_entity will be set. */
610 && !(TREE_CODE (x
) == PARM_DECL
611 && current_binding_level
->kind
== sk_function_parms
612 && current_binding_level
->this_entity
== NULL
)
613 && !DECL_CONTEXT (x
))
614 DECL_CONTEXT (x
) = current_function_decl
;
616 /* If this is the declaration for a namespace-scope function,
617 but the declaration itself is in a local scope, mark the
619 if (TREE_CODE (x
) == FUNCTION_DECL
620 && DECL_NAMESPACE_SCOPE_P (x
)
621 && current_function_decl
622 && x
!= current_function_decl
)
623 DECL_LOCAL_FUNCTION_P (x
) = 1;
626 name
= DECL_NAME (x
);
629 int different_binding_level
= 0;
631 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
632 name
= TREE_OPERAND (name
, 0);
634 /* In case this decl was explicitly namespace-qualified, look it
635 up in its namespace context. */
636 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
637 t
= namespace_binding (name
, DECL_CONTEXT (x
));
639 t
= lookup_name_innermost_nonclass_level (name
);
641 /* [basic.link] If there is a visible declaration of an entity
642 with linkage having the same name and type, ignoring entities
643 declared outside the innermost enclosing namespace scope, the
644 block scope declaration declares that same entity and
645 receives the linkage of the previous declaration. */
646 if (! t
&& current_function_decl
&& x
!= current_function_decl
647 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
648 && DECL_EXTERNAL (x
))
650 /* Look in block scope. */
651 t
= innermost_non_namespace_value (name
);
652 /* Or in the innermost namespace. */
654 t
= namespace_binding (name
, DECL_CONTEXT (x
));
655 /* Does it have linkage? Note that if this isn't a DECL, it's an
656 OVERLOAD, which is OK. */
657 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
660 different_binding_level
= 1;
663 /* If we are declaring a function, and the result of name-lookup
664 was an OVERLOAD, look for an overloaded instance that is
665 actually the same as the function we are declaring. (If
666 there is one, we have to merge our declaration with the
667 previous declaration.) */
668 if (t
&& TREE_CODE (t
) == OVERLOAD
)
672 if (TREE_CODE (x
) == FUNCTION_DECL
)
673 for (match
= t
; match
; match
= OVL_NEXT (match
))
675 if (decls_match (OVL_CURRENT (match
), x
))
679 /* Just choose one. */
683 t
= OVL_CURRENT (match
);
688 if (t
&& t
!= error_mark_node
)
690 if (different_binding_level
)
692 if (decls_match (x
, t
))
693 /* The standard only says that the local extern
694 inherits linkage from the previous decl; in
695 particular, default args are not shared. Add
696 the decl into a hash table to make sure only
697 the previous decl in this case is seen by the
700 struct cxx_int_tree_map
*h
;
703 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
705 if (cp_function_chain
->extern_decl_map
== NULL
)
706 cp_function_chain
->extern_decl_map
707 = htab_create_ggc (20, cxx_int_tree_map_hash
,
708 cxx_int_tree_map_eq
, NULL
);
710 h
= ggc_alloc_cxx_int_tree_map ();
711 h
->uid
= DECL_UID (x
);
713 loc
= htab_find_slot_with_hash
714 (cp_function_chain
->extern_decl_map
, h
,
716 *(struct cxx_int_tree_map
**) loc
= h
;
719 else if (TREE_CODE (t
) == PARM_DECL
)
721 /* Check for duplicate params. */
722 tree d
= duplicate_decls (x
, t
, is_friend
);
724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, d
);
726 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
727 || DECL_FUNCTION_TEMPLATE_P (x
))
728 && is_overloaded_fn (t
))
729 /* Don't do anything just yet. */;
730 else if (t
== wchar_decl_node
)
732 if (! DECL_IN_SYSTEM_HEADER (x
))
733 pedwarn (input_location
, OPT_pedantic
, "redeclaration of %<wchar_t%> as %qT",
736 /* Throw away the redeclaration. */
737 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
741 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
743 /* If the redeclaration failed, we can stop at this
745 if (olddecl
== error_mark_node
)
746 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
750 if (TREE_CODE (t
) == TYPE_DECL
)
751 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
753 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
755 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
757 /* A redeclaration of main, but not a duplicate of the
762 This function shall not be overloaded. */
763 error ("invalid redeclaration of %q+D", t
);
765 /* We don't try to push this declaration since that
767 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
772 /* If x has C linkage-specification, (extern "C"),
773 lookup its binding, in case it's already bound to an object.
774 The lookup is done in all namespaces.
775 If we find an existing binding, make sure it has the same
776 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
777 if ((TREE_CODE (x
) == FUNCTION_DECL
)
778 && DECL_EXTERN_C_P (x
)
779 /* We should ignore declarations happening in system headers. */
780 && !DECL_ARTIFICIAL (x
)
781 && !DECL_IN_SYSTEM_HEADER (x
))
783 cxx_binding
*function_binding
=
784 lookup_extern_c_fun_binding_in_all_ns (x
);
785 tree previous
= (function_binding
786 ? function_binding
->value
789 && !DECL_ARTIFICIAL (previous
)
790 && !DECL_IN_SYSTEM_HEADER (previous
)
791 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
793 tree previous
= function_binding
->value
;
795 /* In case either x or previous is declared to throw an exception,
796 make sure both exception specifications are equal. */
797 if (decls_match (x
, previous
))
799 tree x_exception_spec
= NULL_TREE
;
800 tree previous_exception_spec
= NULL_TREE
;
803 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
804 previous_exception_spec
=
805 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
806 if (!comp_except_specs (previous_exception_spec
,
810 pedwarn (input_location
, 0, "declaration of %q#D with C language linkage",
812 pedwarn (input_location
, 0, "conflicts with previous declaration %q+#D",
814 pedwarn (input_location
, 0, "due to different exception specifications");
815 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
820 pedwarn (input_location
, 0,
821 "declaration of %q#D with C language linkage", x
);
822 pedwarn (input_location
, 0,
823 "conflicts with previous declaration %q+#D",
829 check_template_shadow (x
);
831 /* If this is a function conjured up by the back end, massage it
832 so it looks friendly. */
833 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
835 retrofit_lang_decl (x
);
836 SET_DECL_LANGUAGE (x
, lang_c
);
840 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
842 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
843 if (!namespace_bindings_p ())
844 /* We do not need to create a binding for this name;
845 push_overloaded_decl will have already done so if
847 need_new_binding
= 0;
849 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
851 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
853 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
856 if (TREE_CODE (t
) == FUNCTION_DECL
|| DECL_FUNCTION_TEMPLATE_P (t
))
857 check_default_args (t
);
859 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
860 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
862 /* If declaring a type as a typedef, copy the type (unless we're
863 at line 0), and install this TYPE_DECL as the new type's typedef
864 name. See the extensive comment of set_underlying_type (). */
865 if (TREE_CODE (x
) == TYPE_DECL
)
867 tree type
= TREE_TYPE (x
);
869 if (DECL_IS_BUILTIN (x
)
870 || (TREE_TYPE (x
) != error_mark_node
871 && TYPE_NAME (type
) != x
872 /* We don't want to copy the type when all we're
873 doing is making a TYPE_DECL for the purposes of
875 && (!TYPE_NAME (type
)
876 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
877 cp_set_underlying_type (x
);
879 if (type
!= error_mark_node
881 && TYPE_IDENTIFIER (type
))
882 set_identifier_type_value (DECL_NAME (x
), x
);
885 /* Multiple external decls of the same identifier ought to match.
887 We get warnings about inline functions where they are defined.
888 We get warnings about other functions from push_overloaded_decl.
890 Avoid duplicate warnings where they are used. */
891 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
895 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
896 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
897 decl
= OVL_FUNCTION (decl
);
899 if (decl
&& decl
!= error_mark_node
900 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
901 /* If different sort of thing, we already gave an error. */
902 && TREE_CODE (decl
) == TREE_CODE (x
)
903 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
905 permerror (input_location
, "type mismatch with previous external decl of %q#D", x
);
906 permerror (input_location
, "previous external decl of %q+#D", decl
);
910 if (TREE_CODE (x
) == FUNCTION_DECL
912 && !flag_friend_injection
)
914 /* This is a new declaration of a friend function, so hide
915 it from ordinary function lookup. */
916 DECL_ANTICIPATED (x
) = 1;
917 DECL_HIDDEN_FRIEND_P (x
) = 1;
920 /* This name is new in its binding level.
921 Install the new declaration and return it. */
922 if (namespace_bindings_p ())
924 /* Install a global value. */
926 /* If the first global decl has external linkage,
927 warn if we later see static one. */
928 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
929 TREE_PUBLIC (name
) = 1;
931 /* Bind the name for the entity. */
932 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
934 && (TREE_CODE (x
) == TYPE_DECL
935 || TREE_CODE (x
) == VAR_DECL
936 || TREE_CODE (x
) == NAMESPACE_DECL
937 || TREE_CODE (x
) == CONST_DECL
938 || TREE_CODE (x
) == TEMPLATE_DECL
))
939 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
941 /* If new decl is `static' and an `extern' was seen previously,
943 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
944 warn_extern_redeclared_static (x
, t
);
948 /* Here to install a non-global value. */
949 tree oldlocal
= innermost_non_namespace_value (name
);
950 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
952 if (need_new_binding
)
954 push_local_binding (name
, x
, 0);
955 /* Because push_local_binding will hook X on to the
956 current_binding_level's name list, we don't want to
957 do that again below. */
958 need_new_binding
= 0;
961 /* If this is a TYPE_DECL, push it into the type value slot. */
962 if (TREE_CODE (x
) == TYPE_DECL
)
963 set_identifier_type_value (name
, x
);
965 /* Clear out any TYPE_DECL shadowed by a namespace so that
966 we won't think this is a type. The C struct hack doesn't
967 go through namespaces. */
968 if (TREE_CODE (x
) == NAMESPACE_DECL
)
969 set_identifier_type_value (name
, NULL_TREE
);
976 && TREE_CODE (oldlocal
) == VAR_DECL
977 && DECL_DEAD_FOR_LOCAL (oldlocal
))
978 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
980 if (oldlocal
== NULL_TREE
)
981 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
984 /* If this is an extern function declaration, see if we
985 have a global definition or declaration for the function. */
986 if (oldlocal
== NULL_TREE
988 && oldglobal
!= NULL_TREE
989 && TREE_CODE (x
) == FUNCTION_DECL
990 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
992 /* We have one. Their types must agree. */
993 if (decls_match (x
, oldglobal
))
997 warning (0, "extern declaration of %q#D doesn't match", x
);
998 warning (0, "global declaration %q+#D", oldglobal
);
1001 /* If we have a local external declaration,
1002 and no file-scope declaration has yet been seen,
1003 then if we later have a file-scope decl it must not be static. */
1004 if (oldlocal
== NULL_TREE
1005 && oldglobal
== NULL_TREE
1006 && DECL_EXTERNAL (x
)
1008 TREE_PUBLIC (name
) = 1;
1010 /* Don't complain about the parms we push and then pop
1011 while tentatively parsing a function declarator. */
1012 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1015 /* Warn if shadowing an argument at the top level of the body. */
1016 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1017 /* Inline decls shadow nothing. */
1018 && !DECL_FROM_INLINE (x
)
1019 && (TREE_CODE (oldlocal
) == PARM_DECL
1020 || TREE_CODE (oldlocal
) == VAR_DECL
)
1021 /* Don't check the `this' parameter. */
1022 && !DECL_ARTIFICIAL (oldlocal
)
1023 && !DECL_ARTIFICIAL (x
))
1025 bool nowarn
= false;
1027 /* Don't complain if it's from an enclosing function. */
1028 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1029 && TREE_CODE (x
) != PARM_DECL
1030 && TREE_CODE (oldlocal
) == PARM_DECL
)
1032 /* Go to where the parms should be and see if we find
1034 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
1036 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1037 /* Skip the ctor/dtor cleanup level. */
1041 if (b
->kind
== sk_function_parms
)
1043 error ("declaration of %q#D shadows a parameter", x
);
1048 /* The local structure or class can't use parameters of
1049 the containing function anyway. */
1050 if (DECL_CONTEXT (oldlocal
) != current_function_decl
)
1052 cxx_scope
*scope
= current_binding_level
;
1053 tree context
= DECL_CONTEXT (oldlocal
);
1054 for (; scope
; scope
= scope
->level_chain
)
1056 if (scope
->kind
== sk_function_parms
1057 && scope
->this_entity
== context
)
1059 if (scope
->kind
== sk_class
1060 && !LAMBDA_TYPE_P (scope
->this_entity
))
1068 if (warn_shadow
&& !nowarn
)
1070 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1071 warning_at (input_location
, OPT_Wshadow
,
1072 "declaration of %q#D shadows a parameter", x
);
1074 warning_at (input_location
, OPT_Wshadow
,
1075 "declaration of %qD shadows a previous local",
1077 warning_at (DECL_SOURCE_LOCATION (oldlocal
), OPT_Wshadow
,
1078 "shadowed declaration is here");
1082 /* Maybe warn if shadowing something else. */
1083 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1084 /* No shadow warnings for internally generated vars. */
1085 && ! DECL_ARTIFICIAL (x
)
1086 /* No shadow warnings for vars made for inlining. */
1087 && ! DECL_FROM_INLINE (x
))
1091 if (current_class_ptr
)
1092 member
= lookup_member (current_class_type
,
1095 /*want_type=*/false);
1099 if (member
&& !TREE_STATIC (member
))
1101 /* Location of previous decl is not useful in this case. */
1102 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
1105 else if (oldglobal
!= NULL_TREE
1106 && TREE_CODE (oldglobal
) == VAR_DECL
)
1107 /* XXX shadow warnings in outer-more namespaces */
1109 warning_at (input_location
, OPT_Wshadow
,
1110 "declaration of %qD shadows a global declaration", x
);
1111 warning_at (DECL_SOURCE_LOCATION (oldglobal
), OPT_Wshadow
,
1112 "shadowed declaration is here");
1117 if (TREE_CODE (x
) == VAR_DECL
)
1118 maybe_register_incomplete_var (x
);
1121 if (need_new_binding
)
1122 add_decl_to_level (x
,
1123 DECL_NAMESPACE_SCOPE_P (x
)
1124 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1125 : current_binding_level
);
1127 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1130 /* Record a decl-node X as belonging to the current lexical scope. */
1135 return pushdecl_maybe_friend (x
, false);
1138 /* Enter DECL into the symbol table, if that's appropriate. Returns
1139 DECL, or a modified version thereof. */
1142 maybe_push_decl (tree decl
)
1144 tree type
= TREE_TYPE (decl
);
1146 /* Add this decl to the current binding level, but not if it comes
1147 from another scope, e.g. a static member variable. TEM may equal
1148 DECL or it may be a previous decl of the same name. */
1149 if (decl
== error_mark_node
1150 || (TREE_CODE (decl
) != PARM_DECL
1151 && DECL_CONTEXT (decl
) != NULL_TREE
1152 /* Definitions of namespace members outside their namespace are
1154 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
1155 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1156 || type
== unknown_type_node
1157 /* The declaration of a template specialization does not affect
1158 the functions available for overload resolution, so we do not
1160 || (TREE_CODE (decl
) == FUNCTION_DECL
1161 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1164 return pushdecl (decl
);
1167 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1168 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1169 doesn't really belong to this binding level, that it got here
1170 through a using-declaration. */
1173 push_local_binding (tree id
, tree decl
, int flags
)
1175 struct cp_binding_level
*b
;
1177 /* Skip over any local classes. This makes sense if we call
1178 push_local_binding with a friend decl of a local class. */
1179 b
= innermost_nonclass_level ();
1181 if (lookup_name_innermost_nonclass_level (id
))
1183 /* Supplement the existing binding. */
1184 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1185 /* It didn't work. Something else must be bound at this
1186 level. Do not add DECL to the list of things to pop
1191 /* Create a new binding. */
1192 push_binding (id
, decl
, b
);
1194 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1195 /* We must put the OVERLOAD into a TREE_LIST since the
1196 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1197 decls that got here through a using-declaration. */
1198 decl
= build_tree_list (NULL_TREE
, decl
);
1200 /* And put DECL on the list of things declared by the current
1202 add_decl_to_level (decl
, b
);
1205 /* Check to see whether or not DECL is a variable that would have been
1206 in scope under the ARM, but is not in scope under the ANSI/ISO
1207 standard. If so, issue an error message. If name lookup would
1208 work in both cases, but return a different result, this function
1209 returns the result of ANSI/ISO lookup. Otherwise, it returns
1213 check_for_out_of_scope_variable (tree decl
)
1217 /* We only care about out of scope variables. */
1218 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1221 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1222 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1223 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1224 && DECL_DEAD_FOR_LOCAL (shadowed
))
1225 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1226 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1228 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1231 if (!DECL_ERROR_REPORTED (decl
))
1233 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1234 warning (0, " matches this %q+D under ISO standard rules",
1236 warning (0, " matches this %q+D under old rules", decl
);
1237 DECL_ERROR_REPORTED (decl
) = 1;
1242 /* If we have already complained about this declaration, there's no
1243 need to do it again. */
1244 if (DECL_ERROR_REPORTED (decl
))
1247 DECL_ERROR_REPORTED (decl
) = 1;
1249 if (TREE_TYPE (decl
) == error_mark_node
)
1252 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1254 error ("name lookup of %qD changed for ISO %<for%> scoping",
1256 error (" cannot use obsolete binding at %q+D because "
1257 "it has a destructor", decl
);
1258 return error_mark_node
;
1262 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1264 if (flag_permissive
)
1265 permerror (input_location
, " using obsolete binding at %q+D", decl
);
1271 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1280 /* true means unconditionally make a BLOCK for the next level pushed. */
1282 static bool keep_next_level_flag
;
1284 static int binding_depth
= 0;
1291 for (i
= 0; i
< depth
* 2; i
++)
1295 /* Return a string describing the kind of SCOPE we have. */
1297 cxx_scope_descriptor (cxx_scope
*scope
)
1299 /* The order of this table must match the "scope_kind"
1301 static const char* scope_kind_names
[] = {
1307 "function-parameter-scope",
1310 "template-parameter-scope",
1311 "template-explicit-spec-scope"
1313 const scope_kind kind
= scope
->explicit_spec_p
1314 ? sk_template_spec
: scope
->kind
;
1316 return scope_kind_names
[kind
];
1319 /* Output a debugging information about SCOPE when performing
1322 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1324 const char *desc
= cxx_scope_descriptor (scope
);
1325 if (scope
->this_entity
)
1326 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1327 scope
->this_entity
, (void *) scope
, line
);
1329 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1332 /* Return the estimated initial size of the hashtable of a NAMESPACE
1335 static inline size_t
1336 namespace_scope_ht_size (tree ns
)
1338 tree name
= DECL_NAME (ns
);
1340 return name
== std_identifier
1341 ? NAMESPACE_STD_HT_SIZE
1342 : (name
== global_scope_name
1343 ? GLOBAL_SCOPE_HT_SIZE
1344 : NAMESPACE_ORDINARY_HT_SIZE
);
1347 /* A chain of binding_level structures awaiting reuse. */
1349 static GTY((deletable
)) struct cp_binding_level
*free_binding_level
;
1351 /* Insert SCOPE as the innermost binding level. */
1354 push_binding_level (struct cp_binding_level
*scope
)
1356 /* Add it to the front of currently active scopes stack. */
1357 scope
->level_chain
= current_binding_level
;
1358 current_binding_level
= scope
;
1359 keep_next_level_flag
= false;
1361 if (ENABLE_SCOPE_CHECKING
)
1363 scope
->binding_depth
= binding_depth
;
1364 indent (binding_depth
);
1365 cxx_scope_debug (scope
, input_line
, "push");
1370 /* Create a new KIND scope and make it the top of the active scopes stack.
1371 ENTITY is the scope of the associated C++ entity (namespace, class,
1372 function, C++0x enumeration); it is NULL otherwise. */
1375 begin_scope (scope_kind kind
, tree entity
)
1379 /* Reuse or create a struct for this binding level. */
1380 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1382 scope
= free_binding_level
;
1383 memset (scope
, 0, sizeof (cxx_scope
));
1384 free_binding_level
= scope
->level_chain
;
1387 scope
= ggc_alloc_cleared_cxx_scope ();
1389 scope
->this_entity
= entity
;
1390 scope
->more_cleanups_ok
= true;
1397 case sk_template_spec
:
1398 scope
->explicit_spec_p
= true;
1399 kind
= sk_template_parms
;
1401 case sk_template_parms
:
1407 case sk_scoped_enum
:
1408 case sk_function_parms
:
1410 scope
->keep
= keep_next_level_flag
;
1414 NAMESPACE_LEVEL (entity
) = scope
;
1415 scope
->static_decls
=
1416 VEC_alloc (tree
, gc
,
1417 DECL_NAME (entity
) == std_identifier
1418 || DECL_NAME (entity
) == global_scope_name
1423 /* Should not happen. */
1429 push_binding_level (scope
);
1434 /* We're about to leave current scope. Pop the top of the stack of
1435 currently active scopes. Return the enclosing scope, now active. */
1440 cxx_scope
*scope
= current_binding_level
;
1442 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1443 current_binding_level
= class_binding_level
;
1445 /* We cannot leave a scope, if there are none left. */
1446 if (NAMESPACE_LEVEL (global_namespace
))
1447 gcc_assert (!global_scope_p (scope
));
1449 if (ENABLE_SCOPE_CHECKING
)
1451 indent (--binding_depth
);
1452 cxx_scope_debug (scope
, input_line
, "leave");
1455 /* Move one nesting level up. */
1456 current_binding_level
= scope
->level_chain
;
1458 /* Namespace-scopes are left most probably temporarily, not
1459 completely; they can be reopened later, e.g. in namespace-extension
1460 or any name binding activity that requires us to resume a
1461 namespace. For classes, we cache some binding levels. For other
1462 scopes, we just make the structure available for reuse. */
1463 if (scope
->kind
!= sk_namespace
1464 && scope
->kind
!= sk_class
)
1466 scope
->level_chain
= free_binding_level
;
1467 gcc_assert (!ENABLE_SCOPE_CHECKING
1468 || scope
->binding_depth
== binding_depth
);
1469 free_binding_level
= scope
;
1472 /* Find the innermost enclosing class scope, and reset
1473 CLASS_BINDING_LEVEL appropriately. */
1474 if (scope
->kind
== sk_class
)
1476 class_binding_level
= NULL
;
1477 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1478 if (scope
->kind
== sk_class
)
1480 class_binding_level
= scope
;
1485 return current_binding_level
;
1489 resume_scope (struct cp_binding_level
* b
)
1491 /* Resuming binding levels is meant only for namespaces,
1492 and those cannot nest into classes. */
1493 gcc_assert (!class_binding_level
);
1494 /* Also, resuming a non-directly nested namespace is a no-no. */
1495 gcc_assert (b
->level_chain
== current_binding_level
);
1496 current_binding_level
= b
;
1497 if (ENABLE_SCOPE_CHECKING
)
1499 b
->binding_depth
= binding_depth
;
1500 indent (binding_depth
);
1501 cxx_scope_debug (b
, input_line
, "resume");
1506 /* Return the innermost binding level that is not for a class scope. */
1509 innermost_nonclass_level (void)
1513 b
= current_binding_level
;
1514 while (b
->kind
== sk_class
)
1520 /* We're defining an object of type TYPE. If it needs a cleanup, but
1521 we're not allowed to add any more objects with cleanups to the current
1522 scope, create a new binding level. */
1525 maybe_push_cleanup_level (tree type
)
1527 if (type
!= error_mark_node
1528 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1529 && current_binding_level
->more_cleanups_ok
== 0)
1531 begin_scope (sk_cleanup
, NULL
);
1532 current_binding_level
->statement_list
= push_stmt_list ();
1536 /* Nonzero if we are currently in the global binding level. */
1539 global_bindings_p (void)
1541 return global_scope_p (current_binding_level
);
1544 /* True if we are currently in a toplevel binding level. This
1545 means either the global binding level or a namespace in a toplevel
1546 binding level. Since there are no non-toplevel namespace levels,
1547 this really means any namespace or template parameter level. We
1548 also include a class whose context is toplevel. */
1551 toplevel_bindings_p (void)
1553 struct cp_binding_level
*b
= innermost_nonclass_level ();
1555 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1558 /* True if this is a namespace scope, or if we are defining a class
1559 which is itself at namespace scope, or whose enclosing class is
1560 such a class, etc. */
1563 namespace_bindings_p (void)
1565 struct cp_binding_level
*b
= innermost_nonclass_level ();
1567 return b
->kind
== sk_namespace
;
1570 /* True if the current level needs to have a BLOCK made. */
1575 return (current_binding_level
->blocks
!= NULL_TREE
1576 || current_binding_level
->keep
1577 || current_binding_level
->kind
== sk_cleanup
1578 || current_binding_level
->names
!= NULL_TREE
1579 || current_binding_level
->using_directives
);
1582 /* Returns the kind of the innermost scope. */
1585 innermost_scope_kind (void)
1587 return current_binding_level
->kind
;
1590 /* Returns true if this scope was created to store template parameters. */
1593 template_parm_scope_p (void)
1595 return innermost_scope_kind () == sk_template_parms
;
1598 /* If KEEP is true, make a BLOCK node for the next binding level,
1599 unconditionally. Otherwise, use the normal logic to decide whether
1600 or not to create a BLOCK. */
1603 keep_next_level (bool keep
)
1605 keep_next_level_flag
= keep
;
1608 /* Return the list of declarations of the current level.
1609 Note that this list is in reverse order unless/until
1610 you nreverse it; and when you do nreverse it, you must
1611 store the result back using `storedecls' or you will lose. */
1616 return current_binding_level
->names
;
1619 /* For debugging. */
1620 static int no_print_functions
= 0;
1621 static int no_print_builtins
= 0;
1624 print_binding_level (struct cp_binding_level
* lvl
)
1628 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1629 if (lvl
->more_cleanups_ok
)
1630 fprintf (stderr
, " more-cleanups-ok");
1631 if (lvl
->have_cleanups
)
1632 fprintf (stderr
, " have-cleanups");
1633 fprintf (stderr
, "\n");
1636 fprintf (stderr
, " names:\t");
1637 /* We can probably fit 3 names to a line? */
1638 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1640 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1642 if (no_print_builtins
1643 && (TREE_CODE (t
) == TYPE_DECL
)
1644 && DECL_IS_BUILTIN (t
))
1647 /* Function decls tend to have longer names. */
1648 if (TREE_CODE (t
) == FUNCTION_DECL
)
1655 fprintf (stderr
, "\n\t");
1658 print_node_brief (stderr
, "", t
, 0);
1659 if (t
== error_mark_node
)
1663 fprintf (stderr
, "\n");
1665 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1668 cp_class_binding
*b
;
1669 fprintf (stderr
, " class-shadowed:");
1671 VEC_iterate(cp_class_binding
, lvl
->class_shadowed
, i
, b
);
1673 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1674 fprintf (stderr
, "\n");
1676 if (lvl
->type_shadowed
)
1678 fprintf (stderr
, " type-shadowed:");
1679 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1681 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1683 fprintf (stderr
, "\n");
1688 print_other_binding_stack (struct cp_binding_level
*stack
)
1690 struct cp_binding_level
*level
;
1691 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1693 fprintf (stderr
, "binding level %p\n", (void *) level
);
1694 print_binding_level (level
);
1699 print_binding_stack (void)
1701 struct cp_binding_level
*b
;
1702 fprintf (stderr
, "current_binding_level=%p\n"
1703 "class_binding_level=%p\n"
1704 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1705 (void *) current_binding_level
, (void *) class_binding_level
,
1706 (void *) NAMESPACE_LEVEL (global_namespace
));
1707 if (class_binding_level
)
1709 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1710 if (b
== current_binding_level
)
1713 b
= class_binding_level
;
1715 b
= current_binding_level
;
1718 b
= current_binding_level
;
1719 print_other_binding_stack (b
);
1720 fprintf (stderr
, "global:\n");
1721 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1724 /* Return the type associated with id. */
1727 identifier_type_value (tree id
)
1729 timevar_push (TV_NAME_LOOKUP
);
1730 /* There is no type with that name, anywhere. */
1731 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1733 /* This is not the type marker, but the real thing. */
1734 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1735 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, REAL_IDENTIFIER_TYPE_VALUE (id
));
1736 /* Have to search for it. It must be on the global level, now.
1737 Ask lookup_name not to return non-types. */
1738 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1740 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, TREE_TYPE (id
));
1741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1744 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1745 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1748 identifier_global_value (tree t
)
1750 return IDENTIFIER_GLOBAL_VALUE (t
);
1753 /* Push a definition of struct, union or enum tag named ID. into
1754 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1755 the tag ID is not already defined. */
1758 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1762 if (b
->kind
!= sk_namespace
)
1764 /* Shadow the marker, not the real thing, so that the marker
1765 gets restored later. */
1766 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1768 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1769 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1770 TREE_TYPE (b
->type_shadowed
) = type
;
1774 cxx_binding
*binding
=
1775 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1778 supplement_binding (binding
, decl
);
1780 binding
->value
= decl
;
1782 /* Store marker instead of real type. */
1783 type
= global_type_node
;
1785 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1788 /* As set_identifier_type_value_with_scope, but using
1789 current_binding_level. */
1792 set_identifier_type_value (tree id
, tree decl
)
1794 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1797 /* Return the name for the constructor (or destructor) for the
1798 specified class TYPE. When given a template, this routine doesn't
1799 lose the specialization. */
1802 constructor_name_full (tree type
)
1804 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1807 /* Return the name for the constructor (or destructor) for the
1808 specified class. When given a template, return the plain
1809 unspecialized name. */
1812 constructor_name (tree type
)
1815 name
= constructor_name_full (type
);
1816 if (IDENTIFIER_TEMPLATE (name
))
1817 name
= IDENTIFIER_TEMPLATE (name
);
1821 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1822 which must be a class type. */
1825 constructor_name_p (tree name
, tree type
)
1829 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
1834 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1837 ctor_name
= constructor_name_full (type
);
1838 if (name
== ctor_name
)
1840 if (IDENTIFIER_TEMPLATE (ctor_name
)
1841 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1846 /* Counter used to create anonymous type names. */
1848 static GTY(()) int anon_cnt
;
1850 /* Return an IDENTIFIER which can be used as a name for
1851 anonymous structs and unions. */
1854 make_anon_name (void)
1858 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1859 return get_identifier (buf
);
1862 /* This code is practically identical to that for creating
1863 anonymous names, but is just used for lambdas instead. This is necessary
1864 because anonymous names are recognized and cannot be passed to template
1866 /* FIXME is this still necessary? */
1868 static GTY(()) int lambda_cnt
= 0;
1871 make_lambda_name (void)
1875 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
1876 return get_identifier (buf
);
1879 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1881 static inline cxx_binding
*
1882 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1884 timevar_push (TV_NAME_LOOKUP
);
1886 for (; binding
!= NULL
; binding
= binding
->previous
)
1887 if (binding
->scope
== scope
)
1888 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
);
1890 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, (cxx_binding
*)0);
1893 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1895 static inline cxx_binding
*
1896 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1898 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1901 /* Fold-in case where NAME is used only once. */
1902 if (scope
== b
->scope
&& b
->previous
== NULL
)
1904 return find_binding (scope
, b
);
1909 /* Always returns a binding for name in scope. If no binding is
1910 found, make a new one. */
1912 static cxx_binding
*
1913 binding_for_name (cxx_scope
*scope
, tree name
)
1915 cxx_binding
*result
;
1917 result
= cxx_scope_find_binding_for_name (scope
, name
);
1920 /* Not found, make a new one. */
1921 result
= cxx_binding_make (NULL
, NULL
);
1922 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1923 result
->scope
= scope
;
1924 result
->is_local
= false;
1925 result
->value_is_inherited
= false;
1926 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1930 /* Walk through the bindings associated to the name of FUNCTION,
1931 and return the first binding that declares a function with a
1932 "C" linkage specification, a.k.a 'extern "C"'.
1933 This function looks for the binding, regardless of which scope it
1934 has been defined in. It basically looks in all the known scopes.
1935 Note that this function does not lookup for bindings of builtin functions
1936 or for functions declared in system headers. */
1938 lookup_extern_c_fun_binding_in_all_ns (tree function
)
1943 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
1945 name
= DECL_NAME (function
);
1946 gcc_assert (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
);
1948 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1950 iter
= iter
->previous
)
1953 && TREE_CODE (iter
->value
) == FUNCTION_DECL
1954 && DECL_EXTERN_C_P (iter
->value
)
1955 && !DECL_ARTIFICIAL (iter
->value
))
1963 /* Insert another USING_DECL into the current binding level, returning
1964 this declaration. If this is a redeclaration, do nothing, and
1965 return NULL_TREE if this not in namespace scope (in namespace
1966 scope, a using decl might extend any previous bindings). */
1969 push_using_decl (tree scope
, tree name
)
1973 timevar_push (TV_NAME_LOOKUP
);
1974 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
1975 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1976 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
1977 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
1980 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
1981 namespace_bindings_p () ? decl
: NULL_TREE
);
1982 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
1983 USING_DECL_SCOPE (decl
) = scope
;
1984 TREE_CHAIN (decl
) = current_binding_level
->usings
;
1985 current_binding_level
->usings
= decl
;
1986 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1989 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1990 caller to set DECL_CONTEXT properly. */
1993 pushdecl_with_scope (tree x
, cxx_scope
*level
, bool is_friend
)
1995 struct cp_binding_level
*b
;
1996 tree function_decl
= current_function_decl
;
1998 timevar_push (TV_NAME_LOOKUP
);
1999 current_function_decl
= NULL_TREE
;
2000 if (level
->kind
== sk_class
)
2002 b
= class_binding_level
;
2003 class_binding_level
= level
;
2004 pushdecl_class_level (x
);
2005 class_binding_level
= b
;
2009 b
= current_binding_level
;
2010 current_binding_level
= level
;
2011 x
= pushdecl_maybe_friend (x
, is_friend
);
2012 current_binding_level
= b
;
2014 current_function_decl
= function_decl
;
2015 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
2018 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2019 other definitions already in place. We get around this by making
2020 the value of the identifier point to a list of all the things that
2021 want to be referenced by that name. It is then up to the users of
2022 that name to decide what to do with that list.
2024 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2025 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2027 FLAGS is a bitwise-or of the following values:
2028 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2030 PUSH_USING: DECL is being pushed as the result of a using
2033 IS_FRIEND is true if this is a friend declaration.
2035 The value returned may be a previous declaration if we guessed wrong
2036 about what language DECL should belong to (C or C++). Otherwise,
2037 it's always DECL (and never something that's not a _DECL). */
2040 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2042 tree name
= DECL_NAME (decl
);
2045 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2047 timevar_push (TV_NAME_LOOKUP
);
2049 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2051 old
= lookup_name_innermost_nonclass_level (name
);
2055 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2057 tree t
= TREE_TYPE (old
);
2058 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2059 && (! DECL_IN_SYSTEM_HEADER (decl
)
2060 || ! DECL_IN_SYSTEM_HEADER (old
)))
2061 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2064 else if (is_overloaded_fn (old
))
2068 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2070 tree fn
= OVL_CURRENT (tmp
);
2073 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2074 && !(flags
& PUSH_USING
)
2075 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2076 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
2077 && ! decls_match (fn
, decl
))
2078 error ("%q#D conflicts with previous using declaration %q#D",
2081 dup
= duplicate_decls (decl
, fn
, is_friend
);
2082 /* If DECL was a redeclaration of FN -- even an invalid
2083 one -- pass that information along to our caller. */
2084 if (dup
== fn
|| dup
== error_mark_node
)
2085 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, dup
);
2088 /* We don't overload implicit built-ins. duplicate_decls()
2089 may fail to merge the decls if the new decl is e.g. a
2090 template function. */
2091 if (TREE_CODE (old
) == FUNCTION_DECL
2092 && DECL_ANTICIPATED (old
)
2093 && !DECL_HIDDEN_FRIEND_P (old
))
2096 else if (old
== error_mark_node
)
2097 /* Ignore the undefined symbol marker. */
2101 error ("previous non-function declaration %q+#D", old
);
2102 error ("conflicts with function declaration %q#D", decl
);
2103 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2107 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2108 /* If it's a using declaration, we always need to build an OVERLOAD,
2109 because it's the only way to remember that the declaration comes
2110 from 'using', and have the lookup behave correctly. */
2111 || (flags
& PUSH_USING
))
2113 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2114 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2116 new_binding
= ovl_cons (decl
, old
);
2117 if (flags
& PUSH_USING
)
2118 OVL_USED (new_binding
) = 1;
2121 /* NAME is not ambiguous. */
2125 set_namespace_binding (name
, current_namespace
, new_binding
);
2128 /* We only create an OVERLOAD if there was a previous binding at
2129 this level, or if decl is a template. In the former case, we
2130 need to remove the old binding and replace it with the new
2131 binding. We must also run through the NAMES on the binding
2132 level where the name was bound to update the chain. */
2134 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2138 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2140 d
= &TREE_CHAIN (*d
))
2142 || (TREE_CODE (*d
) == TREE_LIST
2143 && TREE_VALUE (*d
) == old
))
2145 if (TREE_CODE (*d
) == TREE_LIST
)
2146 /* Just replace the old binding with the new. */
2147 TREE_VALUE (*d
) = new_binding
;
2149 /* Build a TREE_LIST to wrap the OVERLOAD. */
2150 *d
= tree_cons (NULL_TREE
, new_binding
,
2153 /* And update the cxx_binding node. */
2154 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2155 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2158 /* We should always find a previous binding in this case. */
2162 /* Install the new binding. */
2163 push_local_binding (name
, new_binding
, flags
);
2166 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2169 /* Check a non-member using-declaration. Return the name and scope
2170 being used, and the USING_DECL, or NULL_TREE on failure. */
2173 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2175 /* [namespace.udecl]
2176 A using-declaration for a class member shall be a
2177 member-declaration. */
2180 error ("%qT is not a namespace", scope
);
2183 else if (scope
== error_mark_node
)
2186 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2189 A using-declaration shall not name a template-id. */
2190 error ("a using-declaration cannot specify a template-id. "
2191 "Try %<using %D%>", name
);
2195 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2197 error ("namespace %qD not allowed in using-declaration", decl
);
2201 if (TREE_CODE (decl
) == SCOPE_REF
)
2203 /* It's a nested name with template parameter dependent scope.
2204 This can only be using-declaration for class member. */
2205 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2209 if (is_overloaded_fn (decl
))
2210 decl
= get_first_fn (decl
);
2212 gcc_assert (DECL_P (decl
));
2214 /* Make a USING_DECL. */
2215 return push_using_decl (scope
, name
);
2218 /* Process local and global using-declarations. */
2221 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2222 tree
*newval
, tree
*newtype
)
2224 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2226 *newval
= *newtype
= NULL_TREE
;
2227 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2231 if (!decls
.value
&& !decls
.type
)
2233 error ("%qD not declared", name
);
2237 /* Shift the old and new bindings around so we're comparing class and
2238 enumeration names to each other. */
2239 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2245 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2247 decls
.type
= decls
.value
;
2248 decls
.value
= NULL_TREE
;
2251 /* It is impossible to overload a built-in function; any explicit
2252 declaration eliminates the built-in declaration. So, if OLDVAL
2253 is a built-in, then we can just pretend it isn't there. */
2255 && TREE_CODE (oldval
) == FUNCTION_DECL
2256 && DECL_ANTICIPATED (oldval
)
2257 && !DECL_HIDDEN_FRIEND_P (oldval
))
2262 /* Check for using functions. */
2263 if (is_overloaded_fn (decls
.value
))
2267 if (oldval
&& !is_overloaded_fn (oldval
))
2269 error ("%qD is already declared in this scope", name
);
2274 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2276 tree new_fn
= OVL_CURRENT (tmp
);
2278 /* [namespace.udecl]
2280 If a function declaration in namespace scope or block
2281 scope has the same name and the same parameter types as a
2282 function introduced by a using declaration the program is
2284 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2286 tree old_fn
= OVL_CURRENT (tmp1
);
2288 if (new_fn
== old_fn
)
2289 /* The function already exists in the current namespace. */
2291 else if (OVL_USED (tmp1
))
2292 continue; /* this is a using decl */
2293 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2294 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2296 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2297 || DECL_HIDDEN_FRIEND_P (old_fn
));
2299 /* There was already a non-using declaration in
2300 this scope with the same parameter types. If both
2301 are the same extern "C" functions, that's ok. */
2302 if (decls_match (new_fn
, old_fn
))
2306 error ("%qD is already declared in this scope", name
);
2312 /* If we broke out of the loop, there's no reason to add
2313 this function to the using declarations for this
2318 /* If we are adding to an existing OVERLOAD, then we no
2319 longer know the type of the set of functions. */
2320 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2321 TREE_TYPE (*newval
) = unknown_type_node
;
2322 /* Add this new function to the set. */
2323 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2324 /* If there is only one function, then we use its type. (A
2325 using-declaration naming a single function can be used in
2326 contexts where overload resolution cannot be
2328 if (TREE_CODE (*newval
) != OVERLOAD
)
2330 *newval
= ovl_cons (*newval
, NULL_TREE
);
2331 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2333 OVL_USED (*newval
) = 1;
2338 *newval
= decls
.value
;
2339 if (oldval
&& !decls_match (*newval
, oldval
))
2340 error ("%qD is already declared in this scope", name
);
2346 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2348 error ("reference to %qD is ambiguous", name
);
2349 print_candidates (decls
.type
);
2353 *newtype
= decls
.type
;
2354 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2355 error ("%qD is already declared in this scope", name
);
2358 /* If *newval is empty, shift any class or enumeration name down. */
2362 *newtype
= NULL_TREE
;
2366 /* Process a using-declaration at function scope. */
2369 do_local_using_decl (tree decl
, tree scope
, tree name
)
2371 tree oldval
, oldtype
, newval
, newtype
;
2372 tree orig_decl
= decl
;
2374 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2375 if (decl
== NULL_TREE
)
2378 if (building_stmt_tree ()
2379 && at_function_scope_p ())
2380 add_decl_expr (decl
);
2382 oldval
= lookup_name_innermost_nonclass_level (name
);
2383 oldtype
= lookup_type_current_level (name
);
2385 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2389 if (is_overloaded_fn (newval
))
2393 /* We only need to push declarations for those functions
2394 that were not already bound in the current level.
2395 The old value might be NULL_TREE, it might be a single
2396 function, or an OVERLOAD. */
2397 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2398 term
= OVL_FUNCTION (oldval
);
2401 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2403 push_overloaded_decl (OVL_CURRENT (fn
),
2404 PUSH_LOCAL
| PUSH_USING
,
2408 push_local_binding (name
, newval
, PUSH_USING
);
2412 push_local_binding (name
, newtype
, PUSH_USING
);
2413 set_identifier_type_value (name
, newtype
);
2416 /* Emit debug info. */
2417 if (!processing_template_decl
)
2418 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2421 /* Returns true if ROOT (a namespace, class, or function) encloses
2422 CHILD. CHILD may be either a class type or a namespace. */
2425 is_ancestor (tree root
, tree child
)
2427 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2428 || TREE_CODE (root
) == FUNCTION_DECL
2429 || CLASS_TYPE_P (root
)));
2430 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2431 || CLASS_TYPE_P (child
)));
2433 /* The global namespace encloses everything. */
2434 if (root
== global_namespace
)
2439 /* If we've run out of scopes, stop. */
2442 /* If we've reached the ROOT, it encloses CHILD. */
2445 /* Go out one level. */
2447 child
= TYPE_NAME (child
);
2448 child
= DECL_CONTEXT (child
);
2452 /* Enter the class or namespace scope indicated by T suitable for name
2453 lookup. T can be arbitrary scope, not necessary nested inside the
2454 current scope. Returns a non-null scope to pop iff pop_scope
2455 should be called later to exit this scope. */
2460 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2461 push_decl_namespace (t
);
2462 else if (CLASS_TYPE_P (t
))
2464 if (!at_class_scope_p ()
2465 || !same_type_p (current_class_type
, t
))
2466 push_nested_class (t
);
2468 /* T is the same as the current scope. There is therefore no
2469 need to re-enter the scope. Since we are not actually
2470 pushing a new scope, our caller should not call
2478 /* Leave scope pushed by push_scope. */
2485 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2486 pop_decl_namespace ();
2487 else if CLASS_TYPE_P (t
)
2488 pop_nested_class ();
2491 /* Subroutine of push_inner_scope. */
2494 push_inner_scope_r (tree outer
, tree inner
)
2499 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2502 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2504 push_inner_scope_r (outer
, prev
);
2505 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2507 struct cp_binding_level
*save_template_parm
= 0;
2508 /* Temporary take out template parameter scopes. They are saved
2509 in reversed order in save_template_parm. */
2510 while (current_binding_level
->kind
== sk_template_parms
)
2512 struct cp_binding_level
*b
= current_binding_level
;
2513 current_binding_level
= b
->level_chain
;
2514 b
->level_chain
= save_template_parm
;
2515 save_template_parm
= b
;
2518 resume_scope (NAMESPACE_LEVEL (inner
));
2519 current_namespace
= inner
;
2521 /* Restore template parameter scopes. */
2522 while (save_template_parm
)
2524 struct cp_binding_level
*b
= save_template_parm
;
2525 save_template_parm
= b
->level_chain
;
2526 b
->level_chain
= current_binding_level
;
2527 current_binding_level
= b
;
2534 /* Enter the scope INNER from current scope. INNER must be a scope
2535 nested inside current scope. This works with both name lookup and
2536 pushing name into scope. In case a template parameter scope is present,
2537 namespace is pushed under the template parameter scope according to
2538 name lookup rule in 14.6.1/6.
2540 Return the former current scope suitable for pop_inner_scope. */
2543 push_inner_scope (tree inner
)
2545 tree outer
= current_scope ();
2547 outer
= current_namespace
;
2549 push_inner_scope_r (outer
, inner
);
2553 /* Exit the current scope INNER back to scope OUTER. */
2556 pop_inner_scope (tree outer
, tree inner
)
2559 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2562 while (outer
!= inner
)
2564 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2566 struct cp_binding_level
*save_template_parm
= 0;
2567 /* Temporary take out template parameter scopes. They are saved
2568 in reversed order in save_template_parm. */
2569 while (current_binding_level
->kind
== sk_template_parms
)
2571 struct cp_binding_level
*b
= current_binding_level
;
2572 current_binding_level
= b
->level_chain
;
2573 b
->level_chain
= save_template_parm
;
2574 save_template_parm
= b
;
2579 /* Restore template parameter scopes. */
2580 while (save_template_parm
)
2582 struct cp_binding_level
*b
= save_template_parm
;
2583 save_template_parm
= b
->level_chain
;
2584 b
->level_chain
= current_binding_level
;
2585 current_binding_level
= b
;
2591 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2595 /* Do a pushlevel for class declarations. */
2598 pushlevel_class (void)
2600 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2603 /* ...and a poplevel for class declarations. */
2606 poplevel_class (void)
2608 struct cp_binding_level
*level
= class_binding_level
;
2609 cp_class_binding
*cb
;
2613 timevar_push (TV_NAME_LOOKUP
);
2614 gcc_assert (level
!= 0);
2616 /* If we're leaving a toplevel class, cache its binding level. */
2617 if (current_class_depth
== 1)
2618 previous_class_level
= level
;
2619 for (shadowed
= level
->type_shadowed
;
2621 shadowed
= TREE_CHAIN (shadowed
))
2622 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2624 /* Remove the bindings for all of the class-level declarations. */
2625 if (level
->class_shadowed
)
2628 VEC_iterate (cp_class_binding
, level
->class_shadowed
, i
, cb
);
2630 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
.previous
;
2631 ggc_free (level
->class_shadowed
);
2632 level
->class_shadowed
= NULL
;
2635 /* Now, pop out of the binding level which we created up in the
2636 `pushlevel_class' routine. */
2637 gcc_assert (current_binding_level
== level
);
2639 timevar_pop (TV_NAME_LOOKUP
);
2642 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2643 appropriate. DECL is the value to which a name has just been
2644 bound. CLASS_TYPE is the class in which the lookup occurred. */
2647 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2650 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2654 if (TREE_CODE (decl
) == OVERLOAD
)
2655 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2658 gcc_assert (DECL_P (decl
));
2659 context
= context_for_name_lookup (decl
);
2662 if (is_properly_derived_from (class_type
, context
))
2663 INHERITED_VALUE_BINDING_P (binding
) = 1;
2665 INHERITED_VALUE_BINDING_P (binding
) = 0;
2667 else if (binding
->value
== decl
)
2668 /* We only encounter a TREE_LIST when there is an ambiguity in the
2669 base classes. Such an ambiguity can be overridden by a
2670 definition in this class. */
2671 INHERITED_VALUE_BINDING_P (binding
) = 1;
2673 INHERITED_VALUE_BINDING_P (binding
) = 0;
2676 /* Make the declaration of X appear in CLASS scope. */
2679 pushdecl_class_level (tree x
)
2682 bool is_valid
= true;
2684 /* Do nothing if we're adding to an outer lambda closure type,
2685 outer_binding will add it later if it's needed. */
2686 if (current_class_type
!= class_binding_level
->this_entity
)
2689 timevar_push (TV_NAME_LOOKUP
);
2690 /* Get the name of X. */
2691 if (TREE_CODE (x
) == OVERLOAD
)
2692 name
= DECL_NAME (get_first_fn (x
));
2694 name
= DECL_NAME (x
);
2698 is_valid
= push_class_level_binding (name
, x
);
2699 if (TREE_CODE (x
) == TYPE_DECL
)
2700 set_identifier_type_value (name
, x
);
2702 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2704 /* If X is an anonymous aggregate, all of its members are
2705 treated as if they were members of the class containing the
2706 aggregate, for naming purposes. */
2709 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= TREE_CHAIN (f
))
2711 location_t save_location
= input_location
;
2712 input_location
= DECL_SOURCE_LOCATION (f
);
2713 if (!pushdecl_class_level (f
))
2715 input_location
= save_location
;
2718 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, is_valid
);
2721 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2722 scope. If the value returned is non-NULL, and the PREVIOUS field
2723 is not set, callers must set the PREVIOUS field explicitly. */
2725 static cxx_binding
*
2726 get_class_binding (tree name
, cxx_scope
*scope
)
2731 cxx_binding
*binding
;
2733 class_type
= scope
->this_entity
;
2735 /* Get the type binding. */
2736 type_binding
= lookup_member (class_type
, name
,
2737 /*protect=*/2, /*want_type=*/true);
2738 /* Get the value binding. */
2739 value_binding
= lookup_member (class_type
, name
,
2740 /*protect=*/2, /*want_type=*/false);
2743 && (TREE_CODE (value_binding
) == TYPE_DECL
2744 || DECL_CLASS_TEMPLATE_P (value_binding
)
2745 || (TREE_CODE (value_binding
) == TREE_LIST
2746 && TREE_TYPE (value_binding
) == error_mark_node
2747 && (TREE_CODE (TREE_VALUE (value_binding
))
2749 /* We found a type binding, even when looking for a non-type
2750 binding. This means that we already processed this binding
2753 else if (value_binding
)
2755 if (TREE_CODE (value_binding
) == TREE_LIST
2756 && TREE_TYPE (value_binding
) == error_mark_node
)
2757 /* NAME is ambiguous. */
2759 else if (BASELINK_P (value_binding
))
2760 /* NAME is some overloaded functions. */
2761 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2764 /* If we found either a type binding or a value binding, create a
2765 new binding object. */
2766 if (type_binding
|| value_binding
)
2768 binding
= new_class_binding (name
,
2772 /* This is a class-scope binding, not a block-scope binding. */
2773 LOCAL_BINDING_P (binding
) = 0;
2774 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2782 /* Make the declaration(s) of X appear in CLASS scope under the name
2783 NAME. Returns true if the binding is valid. */
2786 push_class_level_binding (tree name
, tree x
)
2788 cxx_binding
*binding
;
2792 timevar_push (TV_NAME_LOOKUP
);
2793 /* The class_binding_level will be NULL if x is a template
2794 parameter name in a member template. */
2795 if (!class_binding_level
)
2796 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2798 if (name
== error_mark_node
)
2799 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2801 /* Check for invalid member names. */
2802 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2803 /* Check that we're pushing into the right binding level. */
2804 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
2806 /* We could have been passed a tree list if this is an ambiguous
2807 declaration. If so, pull the declaration out because
2808 check_template_shadow will not handle a TREE_LIST. */
2809 if (TREE_CODE (decl
) == TREE_LIST
2810 && TREE_TYPE (decl
) == error_mark_node
)
2811 decl
= TREE_VALUE (decl
);
2813 if (!check_template_shadow (decl
))
2814 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2818 If T is the name of a class, then each of the following shall
2819 have a name different from T:
2821 -- every static data member of class T;
2823 -- every member of class T that is itself a type;
2825 -- every enumerator of every member of class T that is an
2828 -- every member of every anonymous union that is a member of
2831 (Non-static data members were also forbidden to have the same
2832 name as T until TC1.) */
2833 if ((TREE_CODE (x
) == VAR_DECL
2834 || TREE_CODE (x
) == CONST_DECL
2835 || (TREE_CODE (x
) == TYPE_DECL
2836 && !DECL_SELF_REFERENCE_P (x
))
2837 /* A data member of an anonymous union. */
2838 || (TREE_CODE (x
) == FIELD_DECL
2839 && DECL_CONTEXT (x
) != current_class_type
))
2840 && DECL_NAME (x
) == constructor_name (current_class_type
))
2842 tree scope
= context_for_name_lookup (x
);
2843 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
2845 error ("%qD has the same name as the class in which it is "
2848 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2852 /* Get the current binding for NAME in this class, if any. */
2853 binding
= IDENTIFIER_BINDING (name
);
2854 if (!binding
|| binding
->scope
!= class_binding_level
)
2856 binding
= get_class_binding (name
, class_binding_level
);
2857 /* If a new binding was created, put it at the front of the
2858 IDENTIFIER_BINDING list. */
2861 binding
->previous
= IDENTIFIER_BINDING (name
);
2862 IDENTIFIER_BINDING (name
) = binding
;
2866 /* If there is already a binding, then we may need to update the
2868 if (binding
&& binding
->value
)
2870 tree bval
= binding
->value
;
2871 tree old_decl
= NULL_TREE
;
2873 if (INHERITED_VALUE_BINDING_P (binding
))
2875 /* If the old binding was from a base class, and was for a
2876 tag name, slide it over to make room for the new binding.
2877 The old binding is still visible if explicitly qualified
2878 with a class-key. */
2879 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2880 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2882 old_decl
= binding
->type
;
2883 binding
->type
= bval
;
2884 binding
->value
= NULL_TREE
;
2885 INHERITED_VALUE_BINDING_P (binding
) = 0;
2890 /* Any inherited type declaration is hidden by the type
2891 declaration in the derived class. */
2892 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
))
2893 binding
->type
= NULL_TREE
;
2896 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2898 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2899 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2900 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
2902 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
2903 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2905 if (old_decl
&& binding
->scope
== class_binding_level
)
2908 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2909 here. This function is only used to register bindings
2910 from with the class definition itself. */
2911 INHERITED_VALUE_BINDING_P (binding
) = 0;
2912 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2916 /* Note that we declared this value so that we can issue an error if
2917 this is an invalid redeclaration of a name already used for some
2919 note_name_declared_in_class (name
, decl
);
2921 /* If we didn't replace an existing binding, put the binding on the
2922 stack of bindings for the identifier, and update the shadowed
2924 if (binding
&& binding
->scope
== class_binding_level
)
2925 /* Supplement the existing binding. */
2926 ok
= supplement_binding (binding
, decl
);
2929 /* Create a new binding. */
2930 push_binding (name
, decl
, class_binding_level
);
2934 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
2937 /* Process "using SCOPE::NAME" in a class scope. Return the
2938 USING_DECL created. */
2941 do_class_using_decl (tree scope
, tree name
)
2943 /* The USING_DECL returned by this function. */
2945 /* The declaration (or declarations) name by this using
2946 declaration. NULL if we are in a template and cannot figure out
2947 what has been named. */
2949 /* True if SCOPE is a dependent type. */
2950 bool scope_dependent_p
;
2951 /* True if SCOPE::NAME is dependent. */
2952 bool name_dependent_p
;
2953 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2954 bool bases_dependent_p
;
2959 if (name
== error_mark_node
)
2962 if (!scope
|| !TYPE_P (scope
))
2964 error ("using-declaration for non-member at class scope");
2968 /* Make sure the name is not invalid */
2969 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2971 error ("%<%T::%D%> names destructor", scope
, name
);
2974 if (MAYBE_CLASS_TYPE_P (scope
) && constructor_name_p (name
, scope
))
2976 error ("%<%T::%D%> names constructor", scope
, name
);
2979 if (constructor_name_p (name
, current_class_type
))
2981 error ("%<%T::%D%> names constructor in %qT",
2982 scope
, name
, current_class_type
);
2986 scope_dependent_p
= dependent_type_p (scope
);
2987 name_dependent_p
= (scope_dependent_p
2988 || (IDENTIFIER_TYPENAME_P (name
)
2989 && dependent_type_p (TREE_TYPE (name
))));
2991 bases_dependent_p
= false;
2992 if (processing_template_decl
)
2993 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
2994 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
2996 if (dependent_type_p (TREE_TYPE (base_binfo
)))
2998 bases_dependent_p
= true;
3004 /* From [namespace.udecl]:
3006 A using-declaration used as a member-declaration shall refer to a
3007 member of a base class of the class being defined.
3009 In general, we cannot check this constraint in a template because
3010 we do not know the entire set of base classes of the current
3011 class type. However, if all of the base classes are
3012 non-dependent, then we can avoid delaying the check until
3014 if (!scope_dependent_p
)
3017 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
3018 if (b_kind
< bk_proper_base
)
3020 if (!bases_dependent_p
)
3022 error_not_base_type (scope
, current_class_type
);
3026 else if (!name_dependent_p
)
3028 decl
= lookup_member (binfo
, name
, 0, false);
3031 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
3035 /* The binfo from which the functions came does not matter. */
3036 if (BASELINK_P (decl
))
3037 decl
= BASELINK_FUNCTIONS (decl
);
3041 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3042 USING_DECL_DECLS (value
) = decl
;
3043 USING_DECL_SCOPE (value
) = scope
;
3044 DECL_DEPENDENT_P (value
) = !decl
;
3050 /* Return the binding value for name in scope. */
3053 namespace_binding (tree name
, tree scope
)
3055 cxx_binding
*binding
;
3058 scope
= global_namespace
;
3060 /* Unnecessary for the global namespace because it can't be an alias. */
3061 scope
= ORIGINAL_NAMESPACE (scope
);
3063 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3065 return binding
? binding
->value
: NULL_TREE
;
3068 /* Set the binding value for name in scope. */
3071 set_namespace_binding (tree name
, tree scope
, tree val
)
3075 timevar_push (TV_NAME_LOOKUP
);
3076 if (scope
== NULL_TREE
)
3077 scope
= global_namespace
;
3078 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3079 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3082 supplement_binding (b
, val
);
3083 timevar_pop (TV_NAME_LOOKUP
);
3086 /* Set the context of a declaration to scope. Complain if we are not
3090 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3094 /* Get rid of namespace aliases. */
3095 scope
= ORIGINAL_NAMESPACE (scope
);
3097 /* It is ok for friends to be qualified in parallel space. */
3098 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3099 error ("declaration of %qD not in a namespace surrounding %qD",
3101 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3103 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3104 if (scope
== current_namespace
)
3106 if (at_namespace_scope_p ())
3107 error ("explicit qualification in declaration of %qD",
3112 /* See whether this has been declared in the namespace. */
3113 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3114 if (old
== error_mark_node
)
3115 /* No old declaration at all. */
3117 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3118 if (TREE_CODE (old
) == TREE_LIST
)
3120 error ("reference to %qD is ambiguous", decl
);
3121 print_candidates (old
);
3124 if (!is_overloaded_fn (decl
))
3126 /* We might have found OLD in an inline namespace inside SCOPE. */
3127 if (TREE_CODE (decl
) == TREE_CODE (old
))
3128 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3129 /* Don't compare non-function decls with decls_match here, since
3130 it can't check for the correct constness at this
3131 point. pushdecl will find those errors later. */
3134 /* Since decl is a function, old should contain a function decl. */
3135 if (!is_overloaded_fn (old
))
3137 /* A template can be explicitly specialized in any namespace. */
3138 if (processing_explicit_instantiation
)
3140 if (processing_template_decl
|| processing_specialization
)
3141 /* We have not yet called push_template_decl to turn a
3142 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3143 match. But, we'll check later, when we construct the
3146 /* Instantiations or specializations of templates may be declared as
3147 friends in any namespace. */
3148 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3150 if (is_overloaded_fn (old
))
3152 tree found
= NULL_TREE
;
3154 for (; elt
; elt
= OVL_NEXT (elt
))
3156 tree ofn
= OVL_CURRENT (elt
);
3157 /* Adjust DECL_CONTEXT first so decls_match will return true
3158 if DECL will match a declaration in an inline namespace. */
3159 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
3160 if (decls_match (decl
, ofn
))
3162 if (found
&& !decls_match (found
, ofn
))
3164 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3165 error ("reference to %qD is ambiguous", decl
);
3166 print_candidates (old
);
3174 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (found
)))
3176 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
3182 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3183 if (decls_match (decl
, old
))
3187 /* It didn't work, go back to the explicit scope. */
3188 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3190 error ("%qD should have been declared inside %qD", decl
, scope
);
3193 /* Return the namespace where the current declaration is declared. */
3196 current_decl_namespace (void)
3199 /* If we have been pushed into a different namespace, use it. */
3200 if (!VEC_empty (tree
, decl_namespace_list
))
3201 return VEC_last (tree
, decl_namespace_list
);
3203 if (current_class_type
)
3204 result
= decl_namespace_context (current_class_type
);
3205 else if (current_function_decl
)
3206 result
= decl_namespace_context (current_function_decl
);
3208 result
= current_namespace
;
3212 /* Process any ATTRIBUTES on a namespace definition. Currently only
3213 attribute visibility is meaningful, which is a property of the syntactic
3214 block rather than the namespace as a whole, so we don't touch the
3215 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3218 handle_namespace_attrs (tree ns
, tree attributes
)
3221 bool saw_vis
= false;
3223 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3225 tree name
= TREE_PURPOSE (d
);
3226 tree args
= TREE_VALUE (d
);
3228 #ifdef HANDLE_PRAGMA_VISIBILITY
3229 if (is_attribute_p ("visibility", name
))
3231 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3232 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3234 warning (OPT_Wattributes
,
3235 "%qD attribute requires a single NTBS argument",
3240 if (!TREE_PUBLIC (ns
))
3241 warning (OPT_Wattributes
,
3242 "%qD attribute is meaningless since members of the "
3243 "anonymous namespace get local symbols", name
);
3245 push_visibility (TREE_STRING_POINTER (x
), 1);
3251 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3260 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3261 select a name that is unique to this compilation unit. */
3264 push_namespace (tree name
)
3268 int implicit_use
= 0;
3271 timevar_push (TV_NAME_LOOKUP
);
3273 /* We should not get here if the global_namespace is not yet constructed
3274 nor if NAME designates the global namespace: The global scope is
3275 constructed elsewhere. */
3276 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3280 name
= get_anonymous_namespace_name();
3281 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3283 /* Reopening anonymous namespace. */
3289 /* Check whether this is an extended namespace definition. */
3290 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3291 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3294 if (DECL_NAMESPACE_ALIAS (d
))
3296 error ("namespace alias %qD not allowed here, assuming %qD",
3297 d
, DECL_NAMESPACE_ALIAS (d
));
3298 d
= DECL_NAMESPACE_ALIAS (d
);
3305 /* Make a new namespace, binding the name to it. */
3306 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3307 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3308 /* The name of this namespace is not visible to other translation
3309 units if it is an anonymous namespace or member thereof. */
3310 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3311 TREE_PUBLIC (d
) = 0;
3313 TREE_PUBLIC (d
) = 1;
3317 /* Clear DECL_NAME for the benefit of debugging back ends. */
3318 SET_DECL_ASSEMBLER_NAME (d
, name
);
3319 DECL_NAME (d
) = NULL_TREE
;
3321 begin_scope (sk_namespace
, d
);
3324 resume_scope (NAMESPACE_LEVEL (d
));
3327 do_using_directive (d
);
3328 /* Enter the name space. */
3329 current_namespace
= d
;
3331 timevar_pop (TV_NAME_LOOKUP
);
3334 /* Pop from the scope of the current namespace. */
3337 pop_namespace (void)
3339 gcc_assert (current_namespace
!= global_namespace
);
3340 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3341 /* The binding level is not popped, as it might be re-opened later. */
3345 /* Push into the scope of the namespace NS, even if it is deeply
3346 nested within another namespace. */
3349 push_nested_namespace (tree ns
)
3351 if (ns
== global_namespace
)
3352 push_to_top_level ();
3355 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3356 push_namespace (DECL_NAME (ns
));
3360 /* Pop back from the scope of the namespace NS, which was previously
3361 entered with push_nested_namespace. */
3364 pop_nested_namespace (tree ns
)
3366 timevar_push (TV_NAME_LOOKUP
);
3367 gcc_assert (current_namespace
== ns
);
3368 while (ns
!= global_namespace
)
3371 ns
= CP_DECL_CONTEXT (ns
);
3374 pop_from_top_level ();
3375 timevar_pop (TV_NAME_LOOKUP
);
3378 /* Temporarily set the namespace for the current declaration. */
3381 push_decl_namespace (tree decl
)
3383 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3384 decl
= decl_namespace_context (decl
);
3385 VEC_safe_push (tree
, gc
, decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
3388 /* [namespace.memdef]/2 */
3391 pop_decl_namespace (void)
3393 VEC_pop (tree
, decl_namespace_list
);
3396 /* Return the namespace that is the common ancestor
3397 of two given namespaces. */
3400 namespace_ancestor (tree ns1
, tree ns2
)
3402 timevar_push (TV_NAME_LOOKUP
);
3403 if (is_ancestor (ns1
, ns2
))
3404 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ns1
);
3405 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
3406 namespace_ancestor (CP_DECL_CONTEXT (ns1
), ns2
));
3409 /* Process a namespace-alias declaration. */
3412 do_namespace_alias (tree alias
, tree name_space
)
3414 if (name_space
== error_mark_node
)
3417 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3419 name_space
= ORIGINAL_NAMESPACE (name_space
);
3421 /* Build the alias. */
3422 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3423 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3424 DECL_EXTERNAL (alias
) = 1;
3425 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3428 /* Emit debug info for namespace alias. */
3429 if (!building_stmt_tree ())
3430 (*debug_hooks
->global_decl
) (alias
);
3433 /* Like pushdecl, only it places X in the current namespace,
3437 pushdecl_namespace_level (tree x
, bool is_friend
)
3439 struct cp_binding_level
*b
= current_binding_level
;
3442 timevar_push (TV_NAME_LOOKUP
);
3443 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3445 /* Now, the type_shadowed stack may screw us. Munge it so it does
3447 if (TREE_CODE (t
) == TYPE_DECL
)
3449 tree name
= DECL_NAME (t
);
3451 tree
*ptr
= (tree
*)0;
3452 for (; !global_scope_p (b
); b
= b
->level_chain
)
3454 tree shadowed
= b
->type_shadowed
;
3455 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3456 if (TREE_PURPOSE (shadowed
) == name
)
3458 ptr
= &TREE_VALUE (shadowed
);
3459 /* Can't break out of the loop here because sometimes
3460 a binding level will have duplicate bindings for
3461 PT names. It's gross, but I haven't time to fix it. */
3464 newval
= TREE_TYPE (t
);
3465 if (ptr
== (tree
*)0)
3467 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3468 up here if this is changed to an assertion. --KR */
3469 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3476 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3479 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3480 directive is not directly from the source. Also find the common
3481 ancestor and let our users know about the new namespace */
3483 add_using_namespace (tree user
, tree used
, bool indirect
)
3486 timevar_push (TV_NAME_LOOKUP
);
3487 /* Using oneself is a no-op. */
3490 timevar_pop (TV_NAME_LOOKUP
);
3493 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3494 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3495 /* Check if we already have this. */
3496 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3500 /* Promote to direct usage. */
3501 TREE_INDIRECT_USING (t
) = 0;
3502 timevar_pop (TV_NAME_LOOKUP
);
3506 /* Add used to the user's using list. */
3507 DECL_NAMESPACE_USING (user
)
3508 = tree_cons (used
, namespace_ancestor (user
, used
),
3509 DECL_NAMESPACE_USING (user
));
3511 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3513 /* Add user to the used's users list. */
3514 DECL_NAMESPACE_USERS (used
)
3515 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3517 /* Recursively add all namespaces used. */
3518 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3519 /* indirect usage */
3520 add_using_namespace (user
, TREE_PURPOSE (t
), 1);
3522 /* Tell everyone using us about the new used namespaces. */
3523 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3524 add_using_namespace (TREE_PURPOSE (t
), used
, 1);
3525 timevar_pop (TV_NAME_LOOKUP
);
3528 /* Process a using-declaration not appearing in class or local scope. */
3531 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3533 tree oldval
, oldtype
, newval
, newtype
;
3534 tree orig_decl
= decl
;
3535 cxx_binding
*binding
;
3537 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3538 if (decl
== NULL_TREE
)
3541 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3543 oldval
= binding
->value
;
3544 oldtype
= binding
->type
;
3546 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3548 /* Emit debug info. */
3549 if (!processing_template_decl
)
3550 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3552 /* Copy declarations found. */
3554 binding
->value
= newval
;
3556 binding
->type
= newtype
;
3559 /* Process a using-directive. */
3562 do_using_directive (tree name_space
)
3564 tree context
= NULL_TREE
;
3566 if (name_space
== error_mark_node
)
3569 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3571 if (building_stmt_tree ())
3572 add_stmt (build_stmt (input_location
, USING_STMT
, name_space
));
3573 name_space
= ORIGINAL_NAMESPACE (name_space
);
3575 if (!toplevel_bindings_p ())
3577 push_using_directive (name_space
);
3582 add_using_namespace (current_namespace
, name_space
, 0);
3583 if (current_namespace
!= global_namespace
)
3584 context
= current_namespace
;
3586 /* Emit debugging info. */
3587 if (!processing_template_decl
)
3588 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
3593 /* Deal with a using-directive seen by the parser. Currently we only
3594 handle attributes here, since they cannot appear inside a template. */
3597 parse_using_directive (tree name_space
, tree attribs
)
3601 do_using_directive (name_space
);
3603 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3605 tree name
= TREE_PURPOSE (a
);
3606 if (is_attribute_p ("strong", name
))
3608 if (!toplevel_bindings_p ())
3609 error ("strong using only meaningful at namespace scope");
3610 else if (name_space
!= error_mark_node
)
3612 if (!is_ancestor (current_namespace
, name_space
))
3613 error ("current namespace %qD does not enclose strongly used namespace %qD",
3614 current_namespace
, name_space
);
3615 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
3616 = tree_cons (current_namespace
, 0,
3617 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
3621 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3625 /* Like pushdecl, only it places X in the global scope if appropriate.
3626 Calls cp_finish_decl to register the variable, initializing it with
3627 *INIT, if INIT is non-NULL. */
3630 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3632 timevar_push (TV_NAME_LOOKUP
);
3633 push_to_top_level ();
3634 x
= pushdecl_namespace_level (x
, is_friend
);
3636 cp_finish_decl (x
, *init
, false, NULL_TREE
, 0);
3637 pop_from_top_level ();
3638 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
3641 /* Like pushdecl, only it places X in the global scope if appropriate. */
3644 pushdecl_top_level (tree x
)
3646 return pushdecl_top_level_1 (x
, NULL
, false);
3649 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3652 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3654 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3657 /* Like pushdecl, only it places X in the global scope if
3658 appropriate. Calls cp_finish_decl to register the variable,
3659 initializing it with INIT. */
3662 pushdecl_top_level_and_finish (tree x
, tree init
)
3664 return pushdecl_top_level_1 (x
, &init
, false);
3667 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3668 duplicates. The first list becomes the tail of the result.
3670 The algorithm is O(n^2). We could get this down to O(n log n) by
3671 doing a sort on the addresses of the functions, if that becomes
3675 merge_functions (tree s1
, tree s2
)
3677 for (; s2
; s2
= OVL_NEXT (s2
))
3679 tree fn2
= OVL_CURRENT (s2
);
3682 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3684 tree fn1
= OVL_CURRENT (fns1
);
3686 /* If the function from S2 is already in S1, there is no
3687 need to add it again. For `extern "C"' functions, we
3688 might have two FUNCTION_DECLs for the same function, in
3689 different namespaces, but let's leave them in in case
3690 they have different default arguments. */
3695 /* If we exhausted all of the functions in S1, FN2 is new. */
3697 s1
= build_overload (fn2
, s1
);
3702 /* Returns TRUE iff OLD and NEW are the same entity.
3704 3 [basic]/3: An entity is a value, object, reference, function,
3705 enumerator, type, class member, template, template specialization,
3706 namespace, parameter pack, or this.
3708 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
3709 in two different namespaces, and the declarations do not declare the
3710 same entity and do not declare functions, the use of the name is
3714 same_entity_p (tree one
, tree two
)
3720 if (TREE_CODE (one
) == TYPE_DECL
3721 && TREE_CODE (two
) == TYPE_DECL
3722 && same_type_p (TREE_TYPE (one
), TREE_TYPE (two
)))
3727 /* This should return an error not all definitions define functions.
3728 It is not an error if we find two functions with exactly the
3729 same signature, only if these are selected in overload resolution.
3730 old is the current set of bindings, new_binding the freshly-found binding.
3731 XXX Do we want to give *all* candidates in case of ambiguity?
3732 XXX In what way should I treat extern declarations?
3733 XXX I don't want to repeat the entire duplicate_decls here */
3736 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
3739 gcc_assert (old
!= NULL
);
3741 /* Copy the type. */
3742 type
= new_binding
->type
;
3743 if (LOOKUP_NAMESPACES_ONLY (flags
)
3744 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
3747 /* Copy the value. */
3748 val
= new_binding
->value
;
3751 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
3754 switch (TREE_CODE (val
))
3757 /* If we expect types or namespaces, and not templates,
3758 or this is not a template class. */
3759 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3760 && !DECL_CLASS_TEMPLATE_P (val
)))
3764 if (LOOKUP_NAMESPACES_ONLY (flags
)
3765 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
3768 case NAMESPACE_DECL
:
3769 if (LOOKUP_TYPES_ONLY (flags
))
3773 /* Ignore built-in functions that are still anticipated. */
3774 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3778 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3783 /* If val is hidden, shift down any class or enumeration name. */
3792 else if (val
&& !same_entity_p (val
, old
->value
))
3794 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3795 old
->value
= merge_functions (old
->value
, val
);
3798 old
->value
= tree_cons (NULL_TREE
, old
->value
,
3799 build_tree_list (NULL_TREE
, val
));
3800 TREE_TYPE (old
->value
) = error_mark_node
;
3806 else if (type
&& old
->type
!= type
)
3808 old
->type
= tree_cons (NULL_TREE
, old
->type
,
3809 build_tree_list (NULL_TREE
, type
));
3810 TREE_TYPE (old
->type
) = error_mark_node
;
3814 /* Return the declarations that are members of the namespace NS. */
3817 cp_namespace_decls (tree ns
)
3819 return NAMESPACE_LEVEL (ns
)->names
;
3822 /* Combine prefer_type and namespaces_only into flags. */
3825 lookup_flags (int prefer_type
, int namespaces_only
)
3827 if (namespaces_only
)
3828 return LOOKUP_PREFER_NAMESPACES
;
3829 if (prefer_type
> 1)
3830 return LOOKUP_PREFER_TYPES
;
3831 if (prefer_type
> 0)
3832 return LOOKUP_PREFER_BOTH
;
3836 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3837 ignore it or not. Subroutine of lookup_name_real and
3838 lookup_type_scope. */
3841 qualify_lookup (tree val
, int flags
)
3843 if (val
== NULL_TREE
)
3845 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3847 if ((flags
& LOOKUP_PREFER_TYPES
)
3848 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3850 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
3852 /* In unevaluated context, look past normal capture fields. */
3853 if (cp_unevaluated_operand
&& TREE_CODE (val
) == FIELD_DECL
3854 && DECL_NORMAL_CAPTURE_P (val
))
3856 /* None of the lookups that use qualify_lookup want the op() from the
3857 lambda; they want the one from the enclosing class. */
3858 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))
3863 /* Given a lookup that returned VAL, decide if we want to ignore it or
3864 not based on DECL_ANTICIPATED. */
3867 hidden_name_p (tree val
)
3870 && DECL_LANG_SPECIFIC (val
)
3871 && DECL_ANTICIPATED (val
))
3876 /* Remove any hidden friend functions from a possibly overloaded set
3880 remove_hidden_names (tree fns
)
3885 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
3887 else if (TREE_CODE (fns
) == OVERLOAD
)
3891 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3892 if (hidden_name_p (OVL_CURRENT (o
)))
3898 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3899 if (!hidden_name_p (OVL_CURRENT (o
)))
3900 n
= build_overload (OVL_CURRENT (o
), n
);
3908 /* Unscoped lookup of a global: iterate over current namespaces,
3909 considering using-directives. */
3912 unqualified_namespace_lookup (tree name
, int flags
)
3914 tree initial
= current_decl_namespace ();
3915 tree scope
= initial
;
3917 struct cp_binding_level
*level
;
3918 tree val
= NULL_TREE
;
3920 timevar_push (TV_NAME_LOOKUP
);
3922 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
3924 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3926 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3929 ambiguous_decl (&binding
, b
, flags
);
3931 /* Add all _DECLs seen through local using-directives. */
3932 for (level
= current_binding_level
;
3933 level
->kind
!= sk_namespace
;
3934 level
= level
->level_chain
)
3935 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
3937 /* Give up because of error. */
3938 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3940 /* Add all _DECLs seen through global using-directives. */
3941 /* XXX local and global using lists should work equally. */
3945 if (!lookup_using_namespace (name
, &binding
,
3946 DECL_NAMESPACE_USING (siter
),
3948 /* Give up because of error. */
3949 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3950 if (siter
== scope
) break;
3951 siter
= CP_DECL_CONTEXT (siter
);
3954 val
= binding
.value
;
3955 if (scope
== global_namespace
)
3958 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3961 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3962 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3965 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3966 declaration found. If no suitable declaration can be found,
3967 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3968 neither a class-type nor a namespace a diagnostic is issued. */
3971 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
3976 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3978 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3980 flags
|= LOOKUP_COMPLAIN
;
3982 flags
|= LOOKUP_PREFER_TYPES
;
3983 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
3986 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
3987 t
= lookup_enumerator (scope
, name
);
3988 else if (is_class_type (scope
, complain
))
3989 t
= lookup_member (scope
, name
, 2, is_type_p
);
3992 return error_mark_node
;
3996 /* Subroutine of unqualified_namespace_lookup:
3997 Add the bindings of NAME in used namespaces to VAL.
3998 We are currently looking for names in namespace SCOPE, so we
3999 look through USINGS for using-directives of namespaces
4000 which have SCOPE as a common ancestor with the current scope.
4001 Returns false on errors. */
4004 lookup_using_namespace (tree name
, struct scope_binding
*val
,
4005 tree usings
, tree scope
, int flags
)
4008 timevar_push (TV_NAME_LOOKUP
);
4009 /* Iterate over all used namespaces in current, searching for using
4010 directives of scope. */
4011 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
4012 if (TREE_VALUE (iter
) == scope
)
4014 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
4016 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
4017 /* Resolve ambiguities. */
4019 ambiguous_decl (val
, val1
, flags
);
4021 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
->value
!= error_mark_node
);
4024 /* Returns true iff VEC contains TARGET. */
4027 tree_vec_contains (VEC(tree
,gc
)* vec
, tree target
)
4031 for (i
= 0; VEC_iterate(tree
,vec
,i
,elt
); ++i
)
4038 Accepts the NAME to lookup and its qualifying SCOPE.
4039 Returns the name/type pair found into the cxx_binding *RESULT,
4040 or false on error. */
4043 qualified_lookup_using_namespace (tree name
, tree scope
,
4044 struct scope_binding
*result
, int flags
)
4046 /* Maintain a list of namespaces visited... */
4047 VEC(tree
,gc
) *seen
= NULL
;
4048 VEC(tree
,gc
) *seen_inline
= NULL
;
4049 /* ... and a list of namespace yet to see. */
4050 VEC(tree
,gc
) *todo
= NULL
;
4051 VEC(tree
,gc
) *todo_maybe
= NULL
;
4052 VEC(tree
,gc
) *todo_inline
= NULL
;
4054 timevar_push (TV_NAME_LOOKUP
);
4055 /* Look through namespace aliases. */
4056 scope
= ORIGINAL_NAMESPACE (scope
);
4058 /* Algorithm: Starting with SCOPE, walk through the the set of used
4059 namespaces. For each used namespace, look through its inline
4060 namespace set for any bindings and usings. If no bindings are found,
4061 add any usings seen to the set of used namespaces. */
4062 VEC_safe_push (tree
, gc
, todo
, scope
);
4064 while (VEC_length (tree
, todo
))
4067 scope
= VEC_pop (tree
, todo
);
4068 if (tree_vec_contains (seen
, scope
))
4070 VEC_safe_push (tree
, gc
, seen
, scope
);
4071 VEC_safe_push (tree
, gc
, todo_inline
, scope
);
4074 while (VEC_length (tree
, todo_inline
))
4076 cxx_binding
*binding
;
4078 scope
= VEC_pop (tree
, todo_inline
);
4079 if (tree_vec_contains (seen_inline
, scope
))
4081 VEC_safe_push (tree
, gc
, seen_inline
, scope
);
4084 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4088 ambiguous_decl (result
, binding
, flags
);
4091 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
4092 usings
= TREE_CHAIN (usings
))
4093 if (!TREE_INDIRECT_USING (usings
))
4095 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
)))
4096 VEC_safe_push (tree
, gc
, todo_inline
, TREE_PURPOSE (usings
));
4098 VEC_safe_push (tree
, gc
, todo_maybe
, TREE_PURPOSE (usings
));
4103 VEC_truncate (tree
, todo_maybe
, 0);
4105 while (VEC_length (tree
, todo_maybe
))
4106 VEC_safe_push (tree
, gc
, todo
, VEC_pop (tree
, todo_maybe
));
4108 VEC_free (tree
,gc
,todo
);
4109 VEC_free (tree
,gc
,todo_maybe
);
4110 VEC_free (tree
,gc
,todo_inline
);
4111 VEC_free (tree
,gc
,seen
);
4112 VEC_free (tree
,gc
,seen_inline
);
4113 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
->value
!= error_mark_node
);
4116 /* Subroutine of outer_binding.
4117 Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
4121 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
4126 if (!binding
|| !scope
)
4129 binding_value
= binding
->value
? binding
->value
: binding
->type
;
4132 && scope
->this_entity
4133 && get_template_info (scope
->this_entity
)
4134 && parameter_of_template_p (binding_value
,
4135 TI_TEMPLATE (get_template_info \
4136 (scope
->this_entity
))));
4139 /* Return the innermost non-namespace binding for NAME from a scope
4140 containing BINDING, or, if BINDING is NULL, the current scope.
4141 Please note that for a given template, the template parameters are
4142 considered to be in the scope containing the current scope.
4143 If CLASS_P is false, then class bindings are ignored. */
4146 outer_binding (tree name
,
4147 cxx_binding
*binding
,
4152 cxx_scope
*outer_scope
;
4156 scope
= binding
->scope
->level_chain
;
4157 outer
= binding
->previous
;
4161 scope
= current_binding_level
;
4162 outer
= IDENTIFIER_BINDING (name
);
4164 outer_scope
= outer
? outer
->scope
: NULL
;
4166 /* Because we create class bindings lazily, we might be missing a
4167 class binding for NAME. If there are any class binding levels
4168 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4169 declared, we must lookup NAME in those class scopes. */
4171 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4173 if (scope
->kind
== sk_class
)
4175 cxx_binding
*class_binding
;
4177 class_binding
= get_class_binding (name
, scope
);
4180 /* Thread this new class-scope binding onto the
4181 IDENTIFIER_BINDING list so that future lookups
4183 class_binding
->previous
= outer
;
4185 binding
->previous
= class_binding
;
4187 IDENTIFIER_BINDING (name
) = class_binding
;
4188 return class_binding
;
4191 /* If we are in a member template, the template parms of the member
4192 template are considered to be inside the scope of the containing
4193 class, but within G++ the class bindings are all pushed between the
4194 template parms and the function body. So if the outer binding is
4195 a template parm for the current scope, return it now rather than
4196 look for a class binding. */
4197 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4198 && binding_to_template_parms_of_scope_p (outer
, scope
))
4201 scope
= scope
->level_chain
;
4207 /* Return the innermost block-scope or class-scope value binding for
4208 NAME, or NULL_TREE if there is no such binding. */
4211 innermost_non_namespace_value (tree name
)
4213 cxx_binding
*binding
;
4214 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4215 return binding
? binding
->value
: NULL_TREE
;
4218 /* Look up NAME in the current binding level and its superiors in the
4219 namespace of variables, functions and typedefs. Return a ..._DECL
4220 node of some kind representing its definition if there is only one
4221 such declaration, or return a TREE_LIST with all the overloaded
4222 definitions if there are many, or return 0 if it is undefined.
4223 Hidden name, either friend declaration or built-in function, are
4226 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4227 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4228 Otherwise we prefer non-TYPE_DECLs.
4230 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4231 BLOCK_P is false, bindings in block scopes are ignored. */
4234 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4235 int namespaces_only
, int flags
)
4238 tree val
= NULL_TREE
;
4240 timevar_push (TV_NAME_LOOKUP
);
4241 /* Conversion operators are handled specially because ordinary
4242 unqualified name lookup will not find template conversion
4244 if (IDENTIFIER_TYPENAME_P (name
))
4246 struct cp_binding_level
*level
;
4248 for (level
= current_binding_level
;
4249 level
&& level
->kind
!= sk_namespace
;
4250 level
= level
->level_chain
)
4255 /* A conversion operator can only be declared in a class
4257 if (level
->kind
!= sk_class
)
4260 /* Lookup the conversion operator in the class. */
4261 class_type
= level
->this_entity
;
4262 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4264 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, operators
);
4267 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4270 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4272 /* First, look in non-namespace scopes. */
4274 if (current_class_type
== NULL_TREE
)
4277 if (block_p
|| !nonclass
)
4278 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4280 iter
= outer_binding (name
, iter
, !nonclass
))
4284 /* Skip entities we don't want. */
4285 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4288 /* If this is the kind of thing we're looking for, we're done. */
4289 if (qualify_lookup (iter
->value
, flags
))
4290 binding
= iter
->value
;
4291 else if ((flags
& LOOKUP_PREFER_TYPES
)
4292 && qualify_lookup (iter
->type
, flags
))
4293 binding
= iter
->type
;
4295 binding
= NULL_TREE
;
4299 if (hidden_name_p (binding
))
4301 /* A non namespace-scope binding can only be hidden in the
4302 presence of a local class, due to friend declarations.
4304 In particular, consider:
4312 B* b; // error: B is hidden
4313 C* c; // OK, finds ::C
4316 B *b; // error: B is hidden
4317 C *c; // OK, finds ::C
4322 The standard says that "B" is a local class in "f"
4323 (but not nested within "A") -- but that name lookup
4324 for "B" does not find this declaration until it is
4325 declared directly with "f".
4331 If a friend declaration appears in a local class and
4332 the name specified is an unqualified name, a prior
4333 declaration is looked up without considering scopes
4334 that are outside the innermost enclosing non-class
4335 scope. For a friend function declaration, if there is
4336 no prior declaration, the program is ill-formed. For a
4337 friend class declaration, if there is no prior
4338 declaration, the class that is specified belongs to the
4339 innermost enclosing non-class scope, but if it is
4340 subsequently referenced, its name is not found by name
4341 lookup until a matching declaration is provided in the
4342 innermost enclosing nonclass scope.
4344 So just keep looking for a non-hidden binding.
4346 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4354 /* Now lookup in namespace scopes. */
4356 val
= unqualified_namespace_lookup (name
, flags
);
4358 /* If we have a single function from a using decl, pull it out. */
4359 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4360 val
= OVL_FUNCTION (val
);
4362 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4366 lookup_name_nonclass (tree name
)
4368 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4372 lookup_function_nonclass (tree name
, VEC(tree
,gc
) *args
, bool block_p
)
4375 lookup_arg_dependent (name
,
4376 lookup_name_real (name
, 0, 1, block_p
, 0,
4382 lookup_name (tree name
)
4384 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4388 lookup_name_prefer_type (tree name
, int prefer_type
)
4390 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
4391 0, LOOKUP_COMPLAIN
);
4394 /* Look up NAME for type used in elaborated name specifier in
4395 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4396 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4397 name, more scopes are checked if cleanup or template parameter
4398 scope is encountered.
4400 Unlike lookup_name_real, we make sure that NAME is actually
4401 declared in the desired scope, not from inheritance, nor using
4402 directive. For using declaration, there is DR138 still waiting
4403 to be resolved. Hidden name coming from an earlier friend
4404 declaration is also returned.
4406 A TYPE_DECL best matching the NAME is returned. Catching error
4407 and issuing diagnostics are caller's responsibility. */
4410 lookup_type_scope (tree name
, tag_scope scope
)
4412 cxx_binding
*iter
= NULL
;
4413 tree val
= NULL_TREE
;
4415 timevar_push (TV_NAME_LOOKUP
);
4417 /* Look in non-namespace scope first. */
4418 if (current_binding_level
->kind
!= sk_namespace
)
4419 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4420 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4422 /* Check if this is the kind of thing we're looking for.
4423 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4424 base class. For ITER->VALUE, we can simply use
4425 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4428 We check ITER->TYPE before ITER->VALUE in order to handle
4429 typedef struct C {} C;
4432 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4433 && (scope
!= ts_current
4434 || LOCAL_BINDING_P (iter
)
4435 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4437 else if ((scope
!= ts_current
4438 || !INHERITED_VALUE_BINDING_P (iter
))
4439 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4446 /* Look in namespace scope. */
4449 iter
= cxx_scope_find_binding_for_name
4450 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4454 /* If this is the kind of thing we're looking for, we're done. */
4455 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4457 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4463 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4464 and template parameter scopes. */
4467 struct cp_binding_level
*b
= current_binding_level
;
4470 if (iter
->scope
== b
)
4471 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4473 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
4474 || b
->kind
== sk_function_parms
)
4476 else if (b
->kind
== sk_class
4477 && scope
== ts_within_enclosing_non_class
)
4484 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4487 /* Similar to `lookup_name' but look only in the innermost non-class
4491 lookup_name_innermost_nonclass_level (tree name
)
4493 struct cp_binding_level
*b
;
4496 timevar_push (TV_NAME_LOOKUP
);
4497 b
= innermost_nonclass_level ();
4499 if (b
->kind
== sk_namespace
)
4501 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4503 /* extern "C" function() */
4504 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4507 else if (IDENTIFIER_BINDING (name
)
4508 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4510 cxx_binding
*binding
;
4511 binding
= IDENTIFIER_BINDING (name
);
4514 if (binding
->scope
== b
4515 && !(TREE_CODE (binding
->value
) == VAR_DECL
4516 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4517 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
->value
);
4519 if (b
->kind
== sk_cleanup
)
4526 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4529 /* Returns true iff DECL is a block-scope extern declaration of a function
4533 is_local_extern (tree decl
)
4535 cxx_binding
*binding
;
4537 /* For functions, this is easy. */
4538 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4539 return DECL_LOCAL_FUNCTION_P (decl
);
4541 if (TREE_CODE (decl
) != VAR_DECL
)
4543 if (!current_function_decl
)
4546 /* For variables, this is not easy. We need to look at the binding stack
4547 for the identifier to see whether the decl we have is a local. */
4548 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
4549 binding
&& binding
->scope
->kind
!= sk_namespace
;
4550 binding
= binding
->previous
)
4551 if (binding
->value
== decl
)
4552 return LOCAL_BINDING_P (binding
);
4557 /* Like lookup_name_innermost_nonclass_level, but for types. */
4560 lookup_type_current_level (tree name
)
4564 timevar_push (TV_NAME_LOOKUP
);
4565 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4567 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4568 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4570 struct cp_binding_level
*b
= current_binding_level
;
4573 if (purpose_member (name
, b
->type_shadowed
))
4574 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
4575 REAL_IDENTIFIER_TYPE_VALUE (name
));
4576 if (b
->kind
== sk_cleanup
)
4583 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4586 /* [basic.lookup.koenig] */
4587 /* A nonzero return value in the functions below indicates an error. */
4593 VEC(tree
,gc
) *namespaces
;
4594 VEC(tree
,gc
) *classes
;
4598 static bool arg_assoc (struct arg_lookup
*, tree
);
4599 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4600 static bool arg_assoc_args_vec (struct arg_lookup
*, VEC(tree
,gc
) *);
4601 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4602 static bool add_function (struct arg_lookup
*, tree
);
4603 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4604 static bool arg_assoc_class_only (struct arg_lookup
*, tree
);
4605 static bool arg_assoc_bases (struct arg_lookup
*, tree
);
4606 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4607 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4609 /* Add a function to the lookup structure.
4610 Returns true on error. */
4613 add_function (struct arg_lookup
*k
, tree fn
)
4615 /* We used to check here to see if the function was already in the list,
4616 but that's O(n^2), which is just too expensive for function lookup.
4617 Now we deal with the occasional duplicate in joust. In doing this, we
4618 assume that the number of duplicates will be small compared to the
4619 total number of functions being compared, which should usually be the
4622 if (!is_overloaded_fn (fn
))
4623 /* All names except those of (possibly overloaded) functions and
4624 function templates are ignored. */;
4625 else if (!k
->functions
)
4627 else if (fn
== k
->functions
)
4630 k
->functions
= build_overload (fn
, k
->functions
);
4635 /* Returns true iff CURRENT has declared itself to be an associated
4636 namespace of SCOPE via a strong using-directive (or transitive chain
4637 thereof). Both are namespaces. */
4640 is_associated_namespace (tree current
, tree scope
)
4642 tree seen
= NULL_TREE
;
4643 tree todo
= NULL_TREE
;
4647 if (scope
== current
)
4649 seen
= tree_cons (scope
, NULL_TREE
, seen
);
4650 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4651 if (!purpose_member (TREE_PURPOSE (t
), seen
))
4652 todo
= tree_cons (TREE_PURPOSE (t
), NULL_TREE
, todo
);
4655 scope
= TREE_PURPOSE (todo
);
4656 todo
= TREE_CHAIN (todo
);
4663 /* Add functions of a namespace to the lookup structure.
4664 Returns true on error. */
4667 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4671 if (vec_member (scope
, k
->namespaces
))
4673 VEC_safe_push (tree
, gc
, k
->namespaces
, scope
);
4675 /* Check out our super-users. */
4676 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4677 value
= TREE_CHAIN (value
))
4678 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4681 /* Also look down into inline namespaces. */
4682 for (value
= DECL_NAMESPACE_USING (scope
); value
;
4683 value
= TREE_CHAIN (value
))
4684 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
4685 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4688 value
= namespace_binding (k
->name
, scope
);
4692 for (; value
; value
= OVL_NEXT (value
))
4694 /* We don't want to find arbitrary hidden functions via argument
4695 dependent lookup. We only want to find friends of associated
4696 classes, which we'll do via arg_assoc_class. */
4697 if (hidden_name_p (OVL_CURRENT (value
)))
4700 if (add_function (k
, OVL_CURRENT (value
)))
4707 /* Adds everything associated with a template argument to the lookup
4708 structure. Returns true on error. */
4711 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4713 /* [basic.lookup.koenig]
4715 If T is a template-id, its associated namespaces and classes are
4716 ... the namespaces and classes associated with the types of the
4717 template arguments provided for template type parameters
4718 (excluding template template parameters); the namespaces in which
4719 any template template arguments are defined; and the classes in
4720 which any member templates used as template template arguments
4721 are defined. [Note: non-type template arguments do not
4722 contribute to the set of associated namespaces. ] */
4724 /* Consider first template template arguments. */
4725 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4726 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
4728 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
4730 tree ctx
= CP_DECL_CONTEXT (arg
);
4732 /* It's not a member template. */
4733 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4734 return arg_assoc_namespace (k
, ctx
);
4735 /* Otherwise, it must be member template. */
4737 return arg_assoc_class_only (k
, ctx
);
4739 /* It's an argument pack; handle it recursively. */
4740 else if (ARGUMENT_PACK_P (arg
))
4742 tree args
= ARGUMENT_PACK_ARGS (arg
);
4743 int i
, len
= TREE_VEC_LENGTH (args
);
4744 for (i
= 0; i
< len
; ++i
)
4745 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
4750 /* It's not a template template argument, but it is a type template
4752 else if (TYPE_P (arg
))
4753 return arg_assoc_type (k
, arg
);
4754 /* It's a non-type template argument. */
4759 /* Adds the class and its friends to the lookup structure.
4760 Returns true on error. */
4763 arg_assoc_class_only (struct arg_lookup
*k
, tree type
)
4765 tree list
, friends
, context
;
4767 /* Backend-built structures, such as __builtin_va_list, aren't
4768 affected by all this. */
4769 if (!CLASS_TYPE_P (type
))
4772 context
= decl_namespace_context (type
);
4773 if (arg_assoc_namespace (k
, context
))
4776 complete_type (type
);
4778 /* Process friends. */
4779 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
4780 list
= TREE_CHAIN (list
))
4781 if (k
->name
== FRIEND_NAME (list
))
4782 for (friends
= FRIEND_DECLS (list
); friends
;
4783 friends
= TREE_CHAIN (friends
))
4785 tree fn
= TREE_VALUE (friends
);
4787 /* Only interested in global functions with potentially hidden
4788 (i.e. unqualified) declarations. */
4789 if (CP_DECL_CONTEXT (fn
) != context
)
4791 /* Template specializations are never found by name lookup.
4792 (Templates themselves can be found, but not template
4793 specializations.) */
4794 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
4796 if (add_function (k
, fn
))
4803 /* Adds the class and its bases to the lookup structure.
4804 Returns true on error. */
4807 arg_assoc_bases (struct arg_lookup
*k
, tree type
)
4809 if (arg_assoc_class_only (k
, type
))
4812 if (TYPE_BINFO (type
))
4814 /* Process baseclasses. */
4815 tree binfo
, base_binfo
;
4818 for (binfo
= TYPE_BINFO (type
), i
= 0;
4819 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4820 if (arg_assoc_bases (k
, BINFO_TYPE (base_binfo
)))
4827 /* Adds everything associated with a class argument type to the lookup
4828 structure. Returns true on error.
4830 If T is a class type (including unions), its associated classes are: the
4831 class itself; the class of which it is a member, if any; and its direct
4832 and indirect base classes. Its associated namespaces are the namespaces
4833 of which its associated classes are members. Furthermore, if T is a
4834 class template specialization, its associated namespaces and classes
4835 also include: the namespaces and classes associated with the types of
4836 the template arguments provided for template type parameters (excluding
4837 template template parameters); the namespaces of which any template
4838 template arguments are members; and the classes of which any member
4839 templates used as template template arguments are members. [ Note:
4840 non-type template arguments do not contribute to the set of associated
4841 namespaces. --end note] */
4844 arg_assoc_class (struct arg_lookup
*k
, tree type
)
4849 /* Backend build structures, such as __builtin_va_list, aren't
4850 affected by all this. */
4851 if (!CLASS_TYPE_P (type
))
4854 if (vec_member (type
, k
->classes
))
4856 VEC_safe_push (tree
, gc
, k
->classes
, type
);
4858 if (TYPE_CLASS_SCOPE_P (type
)
4859 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
4862 if (arg_assoc_bases (k
, type
))
4865 /* Process template arguments. */
4866 if (CLASSTYPE_TEMPLATE_INFO (type
)
4867 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
4869 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
4870 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
4871 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
)))
4878 /* Adds everything associated with a given type.
4879 Returns 1 on error. */
4882 arg_assoc_type (struct arg_lookup
*k
, tree type
)
4884 /* As we do not get the type of non-type dependent expressions
4885 right, we can end up with such things without a type. */
4889 if (TYPE_PTRMEM_P (type
))
4891 /* Pointer to member: associate class type and value type. */
4892 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
4894 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
4896 else switch (TREE_CODE (type
))
4906 case FIXED_POINT_TYPE
:
4910 if (TYPE_PTRMEMFUNC_P (type
))
4911 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
4913 return arg_assoc_class (k
, type
);
4915 case REFERENCE_TYPE
:
4917 return arg_assoc_type (k
, TREE_TYPE (type
));
4919 if (TYPE_CLASS_SCOPE_P (type
)
4920 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
4922 return arg_assoc_namespace (k
, decl_namespace_context (type
));
4924 /* The basetype is referenced in the first arg type, so just
4927 /* Associate the parameter types. */
4928 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
4930 /* Associate the return type. */
4931 return arg_assoc_type (k
, TREE_TYPE (type
));
4932 case TEMPLATE_TYPE_PARM
:
4933 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4938 gcc_assert (type
== unknown_type_node
4939 || NULLPTR_TYPE_P (type
)
4940 || type
== init_list_type_node
);
4942 case TYPE_PACK_EXPANSION
:
4943 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
4951 /* Adds everything associated with arguments. Returns true on error. */
4954 arg_assoc_args (struct arg_lookup
*k
, tree args
)
4956 for (; args
; args
= TREE_CHAIN (args
))
4957 if (arg_assoc (k
, TREE_VALUE (args
)))
4962 /* Adds everything associated with an argument vector. Returns true
4966 arg_assoc_args_vec (struct arg_lookup
*k
, VEC(tree
,gc
) *args
)
4971 for (ix
= 0; VEC_iterate (tree
, args
, ix
, arg
); ++ix
)
4972 if (arg_assoc (k
, arg
))
4977 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4980 arg_assoc (struct arg_lookup
*k
, tree n
)
4982 if (n
== error_mark_node
)
4986 return arg_assoc_type (k
, n
);
4988 if (! type_unknown_p (n
))
4989 return arg_assoc_type (k
, TREE_TYPE (n
));
4991 if (TREE_CODE (n
) == ADDR_EXPR
)
4992 n
= TREE_OPERAND (n
, 0);
4993 if (TREE_CODE (n
) == COMPONENT_REF
)
4994 n
= TREE_OPERAND (n
, 1);
4995 if (TREE_CODE (n
) == OFFSET_REF
)
4996 n
= TREE_OPERAND (n
, 1);
4997 while (TREE_CODE (n
) == TREE_LIST
)
4999 if (TREE_CODE (n
) == BASELINK
)
5000 n
= BASELINK_FUNCTIONS (n
);
5002 if (TREE_CODE (n
) == FUNCTION_DECL
)
5003 return arg_assoc_type (k
, TREE_TYPE (n
));
5004 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
5006 /* The working paper doesn't currently say how to handle template-id
5007 arguments. The sensible thing would seem to be to handle the list
5008 of template candidates like a normal overload set, and handle the
5009 template arguments like we do for class template
5011 tree templ
= TREE_OPERAND (n
, 0);
5012 tree args
= TREE_OPERAND (n
, 1);
5015 /* First the templates. */
5016 if (arg_assoc (k
, templ
))
5019 /* Now the arguments. */
5021 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
5022 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
5025 else if (TREE_CODE (n
) == OVERLOAD
)
5027 for (; n
; n
= OVL_CHAIN (n
))
5028 if (arg_assoc_type (k
, TREE_TYPE (OVL_FUNCTION (n
))))
5035 /* Performs Koenig lookup depending on arguments, where fns
5036 are the functions found in normal lookup. */
5039 lookup_arg_dependent (tree name
, tree fns
, VEC(tree
,gc
) *args
)
5041 struct arg_lookup k
;
5043 timevar_push (TV_NAME_LOOKUP
);
5045 /* Remove any hidden friend functions from the list of functions
5046 found so far. They will be added back by arg_assoc_class as
5048 fns
= remove_hidden_names (fns
);
5053 k
.classes
= make_tree_vector ();
5055 /* We previously performed an optimization here by setting
5056 NAMESPACES to the current namespace when it was safe. However, DR
5057 164 says that namespaces that were already searched in the first
5058 stage of template processing are searched again (potentially
5059 picking up later definitions) in the second stage. */
5060 k
.namespaces
= make_tree_vector ();
5062 arg_assoc_args_vec (&k
, args
);
5067 && TREE_CODE (fns
) != VAR_DECL
5068 && !is_overloaded_fn (fns
))
5070 error ("argument dependent lookup finds %q+D", fns
);
5071 error (" in call to %qD", name
);
5072 fns
= error_mark_node
;
5075 release_tree_vector (k
.classes
);
5076 release_tree_vector (k
.namespaces
);
5078 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, fns
);
5081 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5082 changed (i.e. there was already a directive), or the fresh
5083 TREE_LIST otherwise. */
5086 push_using_directive (tree used
)
5088 tree ud
= current_binding_level
->using_directives
;
5089 tree iter
, ancestor
;
5091 timevar_push (TV_NAME_LOOKUP
);
5092 /* Check if we already have this. */
5093 if (purpose_member (used
, ud
) != NULL_TREE
)
5094 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
5096 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
5097 ud
= current_binding_level
->using_directives
;
5098 ud
= tree_cons (used
, ancestor
, ud
);
5099 current_binding_level
->using_directives
= ud
;
5101 /* Recursively add all namespaces used. */
5102 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
5103 push_using_directive (TREE_PURPOSE (iter
));
5105 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ud
);
5108 /* The type TYPE is being declared. If it is a class template, or a
5109 specialization of a class template, do any processing required and
5110 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5111 being declared a friend. B is the binding level at which this TYPE
5114 Returns the TYPE_DECL for TYPE, which may have been altered by this
5118 maybe_process_template_type_declaration (tree type
, int is_friend
,
5121 tree decl
= TYPE_NAME (type
);
5123 if (processing_template_parmlist
)
5124 /* You can't declare a new template type in a template parameter
5125 list. But, you can declare a non-template type:
5127 template <class A*> struct S;
5129 is a forward-declaration of `A'. */
5131 else if (b
->kind
== sk_namespace
5132 && current_binding_level
->kind
!= sk_namespace
)
5133 /* If this new type is being injected into a containing scope,
5134 then it's not a template type. */
5138 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5139 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5141 if (processing_template_decl
)
5143 /* This may change after the call to
5144 push_template_decl_real, but we want the original value. */
5145 tree name
= DECL_NAME (decl
);
5147 decl
= push_template_decl_real (decl
, is_friend
);
5148 if (decl
== error_mark_node
)
5149 return error_mark_node
;
5151 /* If the current binding level is the binding level for the
5152 template parameters (see the comment in
5153 begin_template_parm_list) and the enclosing level is a class
5154 scope, and we're not looking at a friend, push the
5155 declaration of the member class into the class scope. In the
5156 friend case, push_template_decl will already have put the
5157 friend into global scope, if appropriate. */
5158 if (TREE_CODE (type
) != ENUMERAL_TYPE
5159 && !is_friend
&& b
->kind
== sk_template_parms
5160 && b
->level_chain
->kind
== sk_class
)
5162 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5164 if (!COMPLETE_TYPE_P (current_class_type
))
5166 maybe_add_class_template_decl_list (current_class_type
,
5167 type
, /*friend_p=*/0);
5168 /* Put this UTD in the table of UTDs for the class. */
5169 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5170 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5171 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5173 binding_table_insert
5174 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5183 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5184 that the NAME is a class template, the tag is processed but not pushed.
5186 The pushed scope depend on the SCOPE parameter:
5187 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5189 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5190 non-template-parameter scope. This case is needed for forward
5192 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5193 TS_GLOBAL case except that names within template-parameter scopes
5194 are not pushed at all.
5196 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5199 pushtag (tree name
, tree type
, tag_scope scope
)
5201 struct cp_binding_level
*b
;
5204 timevar_push (TV_NAME_LOOKUP
);
5205 b
= current_binding_level
;
5206 while (/* Cleanup scopes are not scopes from the point of view of
5208 b
->kind
== sk_cleanup
5209 /* Neither are function parameter scopes. */
5210 || b
->kind
== sk_function_parms
5211 /* Neither are the scopes used to hold template parameters
5212 for an explicit specialization. For an ordinary template
5213 declaration, these scopes are not scopes from the point of
5214 view of the language. */
5215 || (b
->kind
== sk_template_parms
5216 && (b
->explicit_spec_p
|| scope
== ts_global
))
5217 || (b
->kind
== sk_class
5218 && (scope
!= ts_current
5219 /* We may be defining a new type in the initializer
5220 of a static member variable. We allow this when
5221 not pedantic, and it is particularly useful for
5222 type punning via an anonymous union. */
5223 || COMPLETE_TYPE_P (b
->this_entity
))))
5226 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5228 /* Do C++ gratuitous typedefing. */
5229 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
5233 tree context
= TYPE_CONTEXT (type
);
5237 tree cs
= current_scope ();
5239 if (scope
== ts_current
5240 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
5242 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5243 /* When declaring a friend class of a local class, we want
5244 to inject the newly named class into the scope
5245 containing the local class, not the namespace
5247 context
= decl_function_context (get_type_decl (cs
));
5250 context
= current_namespace
;
5252 if (b
->kind
== sk_class
5253 || (b
->kind
== sk_template_parms
5254 && b
->level_chain
->kind
== sk_class
))
5257 if (current_lang_name
== lang_name_java
)
5258 TYPE_FOR_JAVA (type
) = 1;
5260 tdef
= create_implicit_typedef (name
, type
);
5261 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5262 if (scope
== ts_within_enclosing_non_class
)
5264 /* This is a friend. Make this TYPE_DECL node hidden from
5265 ordinary name lookup. Its corresponding TEMPLATE_DECL
5266 will be marked in push_template_decl_real. */
5267 retrofit_lang_decl (tdef
);
5268 DECL_ANTICIPATED (tdef
) = 1;
5269 DECL_FRIEND_P (tdef
) = 1;
5272 decl
= maybe_process_template_type_declaration
5273 (type
, scope
== ts_within_enclosing_non_class
, b
);
5274 if (decl
== error_mark_node
)
5275 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
5277 if (b
->kind
== sk_class
)
5279 if (!TYPE_BEING_DEFINED (current_class_type
))
5280 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5282 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5283 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5284 class. But if it's a member template class, we want
5285 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5287 finish_member_declaration (decl
);
5289 pushdecl_class_level (decl
);
5291 else if (b
->kind
!= sk_template_parms
)
5293 decl
= pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
5294 if (decl
== error_mark_node
)
5295 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
5299 set_identifier_type_value_with_scope (name
, tdef
, b
);
5301 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5303 /* If this is a local class, keep track of it. We need this
5304 information for name-mangling, and so that it is possible to
5305 find all function definitions in a translation unit in a
5306 convenient way. (It's otherwise tricky to find a member
5307 function definition it's only pointed to from within a local
5309 if (TYPE_CONTEXT (type
)
5310 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
5311 VEC_safe_push (tree
, gc
, local_classes
, type
);
5313 if (b
->kind
== sk_class
5314 && !COMPLETE_TYPE_P (current_class_type
))
5316 maybe_add_class_template_decl_list (current_class_type
,
5317 type
, /*friend_p=*/0);
5319 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5320 CLASSTYPE_NESTED_UTDS (current_class_type
)
5321 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5323 binding_table_insert
5324 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5327 decl
= TYPE_NAME (type
);
5328 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
5330 /* Set type visibility now if this is a forward declaration. */
5331 TREE_PUBLIC (decl
) = 1;
5332 determine_visibility (decl
);
5334 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, type
);
5337 /* Subroutines for reverting temporarily to top-level for instantiation
5338 of templates and such. We actually need to clear out the class- and
5339 local-value slots of all identifiers, so that only the global values
5340 are at all visible. Simply setting current_binding_level to the global
5341 scope isn't enough, because more binding levels may be pushed. */
5342 struct saved_scope
*scope_chain
;
5344 /* If ID has not already been marked, add an appropriate binding to
5348 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5350 cxx_saved_binding
*saved
;
5352 if (!id
|| !IDENTIFIER_BINDING (id
))
5355 if (IDENTIFIER_MARKED (id
))
5358 IDENTIFIER_MARKED (id
) = 1;
5360 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
5361 saved
->identifier
= id
;
5362 saved
->binding
= IDENTIFIER_BINDING (id
);
5363 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
5364 IDENTIFIER_BINDING (id
) = NULL
;
5368 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5372 timevar_push (TV_NAME_LOOKUP
);
5373 for (t
= names
; t
; t
= TREE_CHAIN (t
))
5377 if (TREE_CODE (t
) == TREE_LIST
)
5378 id
= TREE_PURPOSE (t
);
5382 store_binding (id
, old_bindings
);
5384 timevar_pop (TV_NAME_LOOKUP
);
5387 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5388 objects, rather than a TREE_LIST. */
5391 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
5392 VEC(cxx_saved_binding
,gc
) **old_bindings
)
5395 cp_class_binding
*cb
;
5397 timevar_push (TV_NAME_LOOKUP
);
5398 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
5399 store_binding (cb
->identifier
, old_bindings
);
5400 timevar_pop (TV_NAME_LOOKUP
);
5404 push_to_top_level (void)
5406 struct saved_scope
*s
;
5407 struct cp_binding_level
*b
;
5408 cxx_saved_binding
*sb
;
5412 timevar_push (TV_NAME_LOOKUP
);
5413 s
= ggc_alloc_cleared_saved_scope ();
5415 b
= scope_chain
? current_binding_level
: 0;
5417 /* If we're in the middle of some function, save our state. */
5421 push_function_context ();
5426 if (scope_chain
&& previous_class_level
)
5427 store_class_bindings (previous_class_level
->class_shadowed
,
5430 /* Have to include the global scope, because class-scope decls
5431 aren't listed anywhere useful. */
5432 for (; b
; b
= b
->level_chain
)
5436 /* Template IDs are inserted into the global level. If they were
5437 inserted into namespace level, finish_file wouldn't find them
5438 when doing pending instantiations. Therefore, don't stop at
5439 namespace level, but continue until :: . */
5440 if (global_scope_p (b
))
5443 store_bindings (b
->names
, &s
->old_bindings
);
5444 /* We also need to check class_shadowed to save class-level type
5445 bindings, since pushclass doesn't fill in b->names. */
5446 if (b
->kind
== sk_class
)
5447 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
5449 /* Unwind type-value slots back to top level. */
5450 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
5451 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
5454 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, sb
); ++i
)
5455 IDENTIFIER_MARKED (sb
->identifier
) = 0;
5457 s
->prev
= scope_chain
;
5459 s
->need_pop_function_context
= need_pop
;
5460 s
->function_decl
= current_function_decl
;
5461 s
->unevaluated_operand
= cp_unevaluated_operand
;
5462 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
5465 current_function_decl
= NULL_TREE
;
5466 current_lang_base
= VEC_alloc (tree
, gc
, 10);
5467 current_lang_name
= lang_name_cplusplus
;
5468 current_namespace
= global_namespace
;
5469 push_class_stack ();
5470 cp_unevaluated_operand
= 0;
5471 c_inhibit_evaluation_warnings
= 0;
5472 timevar_pop (TV_NAME_LOOKUP
);
5476 pop_from_top_level (void)
5478 struct saved_scope
*s
= scope_chain
;
5479 cxx_saved_binding
*saved
;
5482 timevar_push (TV_NAME_LOOKUP
);
5483 /* Clear out class-level bindings cache. */
5484 if (previous_class_level
)
5485 invalidate_class_lookup_cache ();
5488 current_lang_base
= 0;
5490 scope_chain
= s
->prev
;
5491 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, saved
); ++i
)
5493 tree id
= saved
->identifier
;
5495 IDENTIFIER_BINDING (id
) = saved
->binding
;
5496 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
5499 /* If we were in the middle of compiling a function, restore our
5501 if (s
->need_pop_function_context
)
5502 pop_function_context ();
5503 current_function_decl
= s
->function_decl
;
5504 cp_unevaluated_operand
= s
->unevaluated_operand
;
5505 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
5506 timevar_pop (TV_NAME_LOOKUP
);
5509 /* Pop off extraneous binding levels left over due to syntax errors.
5511 We don't pop past namespaces, as they might be valid. */
5514 pop_everything (void)
5516 if (ENABLE_SCOPE_CHECKING
)
5517 verbatim ("XXX entering pop_everything ()\n");
5518 while (!toplevel_bindings_p ())
5520 if (current_binding_level
->kind
== sk_class
)
5521 pop_nested_class ();
5525 if (ENABLE_SCOPE_CHECKING
)
5526 verbatim ("XXX leaving pop_everything ()\n");
5529 /* Emit debugging information for using declarations and directives.
5530 If input tree is overloaded fn then emit debug info for all
5534 cp_emit_debug_info_for_using (tree t
, tree context
)
5536 /* Don't try to emit any debug information if we have errors. */
5540 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5541 of a builtin function. */
5542 if (TREE_CODE (t
) == FUNCTION_DECL
5543 && DECL_EXTERNAL (t
)
5544 && DECL_BUILT_IN (t
))
5547 /* Do not supply context to imported_module_or_decl, if
5548 it is a global namespace. */
5549 if (context
== global_namespace
)
5550 context
= NULL_TREE
;
5553 t
= BASELINK_FUNCTIONS (t
);
5555 /* FIXME: Handle TEMPLATE_DECLs. */
5556 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
5557 if (TREE_CODE (t
) != TEMPLATE_DECL
)
5559 if (building_stmt_tree ())
5560 add_stmt (build_stmt (input_location
, USING_STMT
, t
));
5562 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
5566 #include "gt-cp-name-lookup.h"