1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
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.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_NEW (struct 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 binding_table_s
GTY(())
130 /* Array of chains of "binding_entry"s */
131 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
133 /* The number of chains in this table. This is the length of the
134 member "chain" considered as an array. */
137 /* Number of "binding_entry"s in this table. */
141 /* Construct TABLE with an initial CHAIN_COUNT. */
144 binding_table_construct (binding_table table
, size_t chain_count
)
146 table
->chain_count
= chain_count
;
147 table
->entry_count
= 0;
148 table
->chain
= GGC_CNEWVEC (binding_entry
, table
->chain_count
);
151 /* Make TABLE's entries ready for reuse. */
154 binding_table_free (binding_table table
)
162 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
164 binding_entry temp
= table
->chain
[i
];
167 binding_entry entry
= temp
;
169 binding_entry_free (entry
);
171 table
->chain
[i
] = NULL
;
173 table
->entry_count
= 0;
177 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
179 static inline binding_table
180 binding_table_new (size_t chain_count
)
182 binding_table table
= GGC_NEW (struct binding_table_s
);
184 binding_table_construct (table
, chain_count
);
188 /* Expand TABLE to twice its current chain_count. */
191 binding_table_expand (binding_table table
)
193 const size_t old_chain_count
= table
->chain_count
;
194 const size_t old_entry_count
= table
->entry_count
;
195 const size_t new_chain_count
= 2 * old_chain_count
;
196 binding_entry
*old_chains
= table
->chain
;
199 binding_table_construct (table
, new_chain_count
);
200 for (i
= 0; i
< old_chain_count
; ++i
)
202 binding_entry entry
= old_chains
[i
];
203 for (; entry
!= NULL
; entry
= old_chains
[i
])
205 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
206 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
208 old_chains
[i
] = entry
->chain
;
209 entry
->chain
= table
->chain
[j
];
210 table
->chain
[j
] = entry
;
213 table
->entry_count
= old_entry_count
;
216 /* Insert a binding for NAME to TYPE into TABLE. */
219 binding_table_insert (binding_table table
, tree name
, tree type
)
221 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
222 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
223 binding_entry entry
= binding_entry_make (name
, type
);
225 entry
->chain
= table
->chain
[i
];
226 table
->chain
[i
] = entry
;
227 ++table
->entry_count
;
229 if (3 * table
->chain_count
< 5 * table
->entry_count
)
230 binding_table_expand (table
);
233 /* Return the binding_entry, if any, that maps NAME. */
236 binding_table_find (binding_table table
, tree name
)
238 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
239 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
241 while (entry
!= NULL
&& entry
->name
!= name
)
242 entry
= entry
->chain
;
247 /* Apply PROC -- with DATA -- to all entries in TABLE. */
250 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
252 const size_t chain_count
= table
->chain_count
;
255 for (i
= 0; i
< chain_count
; ++i
)
257 binding_entry entry
= table
->chain
[i
];
258 for (; entry
!= NULL
; entry
= entry
->chain
)
263 #ifndef ENABLE_SCOPE_CHECKING
264 # define ENABLE_SCOPE_CHECKING 0
266 # define ENABLE_SCOPE_CHECKING 1
269 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
271 static GTY((deletable
)) cxx_binding
*free_bindings
;
273 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
277 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
279 binding
->value
= value
;
280 binding
->type
= type
;
281 binding
->previous
= NULL
;
284 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
287 cxx_binding_make (tree value
, tree type
)
289 cxx_binding
*binding
;
292 binding
= free_bindings
;
293 free_bindings
= binding
->previous
;
296 binding
= GGC_NEW (cxx_binding
);
298 cxx_binding_init (binding
, value
, type
);
303 /* Put BINDING back on the free list. */
306 cxx_binding_free (cxx_binding
*binding
)
308 binding
->scope
= NULL
;
309 binding
->previous
= free_bindings
;
310 free_bindings
= binding
;
313 /* Create a new binding for NAME (with the indicated VALUE and TYPE
314 bindings) in the class scope indicated by SCOPE. */
317 new_class_binding (tree name
, tree value
, tree type
, cxx_scope
*scope
)
319 cp_class_binding
*cb
;
320 cxx_binding
*binding
;
322 if (VEC_length (cp_class_binding
, scope
->class_shadowed
))
324 cp_class_binding
*old_base
;
325 old_base
= VEC_index (cp_class_binding
, scope
->class_shadowed
, 0);
326 if (VEC_reserve (cp_class_binding
, gc
, scope
->class_shadowed
, 1))
328 /* Fixup the current bindings, as they might have moved. */
332 VEC_iterate (cp_class_binding
, scope
->class_shadowed
, i
, cb
);
336 b
= &IDENTIFIER_BINDING (cb
->identifier
);
337 while (*b
!= &old_base
[i
].base
)
338 b
= &((*b
)->previous
);
342 cb
= VEC_quick_push (cp_class_binding
, scope
->class_shadowed
, NULL
);
345 cb
= VEC_safe_push (cp_class_binding
, gc
, scope
->class_shadowed
, NULL
);
347 cb
->identifier
= name
;
349 binding
->scope
= scope
;
350 cxx_binding_init (binding
, value
, type
);
354 /* Make DECL the innermost binding for ID. The LEVEL is the binding
355 level at which this declaration is being bound. */
358 push_binding (tree id
, tree decl
, cxx_scope
* level
)
360 cxx_binding
*binding
;
362 if (level
!= class_binding_level
)
364 binding
= cxx_binding_make (decl
, NULL_TREE
);
365 binding
->scope
= level
;
368 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
370 /* Now, fill in the binding information. */
371 binding
->previous
= IDENTIFIER_BINDING (id
);
372 INHERITED_VALUE_BINDING_P (binding
) = 0;
373 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
375 /* And put it on the front of the list of bindings for ID. */
376 IDENTIFIER_BINDING (id
) = binding
;
379 /* Remove the binding for DECL which should be the innermost binding
383 pop_binding (tree id
, tree decl
)
385 cxx_binding
*binding
;
388 /* It's easiest to write the loops that call this function without
389 checking whether or not the entities involved have names. We
390 get here for such an entity. */
393 /* Get the innermost binding for ID. */
394 binding
= IDENTIFIER_BINDING (id
);
396 /* The name should be bound. */
397 gcc_assert (binding
!= NULL
);
399 /* The DECL will be either the ordinary binding or the type
400 binding for this identifier. Remove that binding. */
401 if (binding
->value
== decl
)
402 binding
->value
= NULL_TREE
;
405 gcc_assert (binding
->type
== decl
);
406 binding
->type
= NULL_TREE
;
409 if (!binding
->value
&& !binding
->type
)
411 /* We're completely done with the innermost binding for this
412 identifier. Unhook it from the list of bindings. */
413 IDENTIFIER_BINDING (id
) = binding
->previous
;
415 /* Add it to the free list. */
416 cxx_binding_free (binding
);
420 /* BINDING records an existing declaration for a name in the current scope.
421 But, DECL is another declaration for that same identifier in the
422 same scope. This is the `struct stat' hack whereby a non-typedef
423 class name or enum-name can be bound at the same level as some other
427 A class name (9.1) or enumeration name (7.2) can be hidden by the
428 name of an object, function, or enumerator declared in the same scope.
429 If a class or enumeration name and an object, function, or enumerator
430 are declared in the same scope (in any order) with the same name, the
431 class or enumeration name is hidden wherever the object, function, or
432 enumerator name is visible.
434 It's the responsibility of the caller to check that
435 inserting this name is valid here. Returns nonzero if the new binding
439 supplement_binding (cxx_binding
*binding
, tree decl
)
441 tree bval
= binding
->value
;
444 timevar_push (TV_NAME_LOOKUP
);
445 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
446 /* The new name is the type name. */
447 binding
->type
= decl
;
448 else if (/* BVAL is null when push_class_level_binding moves an
449 inherited type-binding out of the way to make room for a
450 new value binding. */
452 /* BVAL is error_mark_node when DECL's name has been used
453 in a non-class scope prior declaration. In that case,
454 we should have already issued a diagnostic; for graceful
455 error recovery purpose, pretend this was the intended
456 declaration for that name. */
457 || bval
== error_mark_node
458 /* If BVAL is anticipated but has not yet been declared,
459 pretend it is not there at all. */
460 || (TREE_CODE (bval
) == FUNCTION_DECL
461 && DECL_ANTICIPATED (bval
)
462 && !DECL_HIDDEN_FRIEND_P (bval
)))
463 binding
->value
= decl
;
464 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
466 /* The old binding was a type name. It was placed in
467 VALUE field because it was thought, at the point it was
468 declared, to be the only entity with such a name. Move the
469 type name into the type slot; it is now hidden by the new
471 binding
->type
= bval
;
472 binding
->value
= decl
;
473 binding
->value_is_inherited
= false;
475 else if (TREE_CODE (bval
) == TYPE_DECL
476 && TREE_CODE (decl
) == TYPE_DECL
477 && DECL_NAME (decl
) == DECL_NAME (bval
)
478 && binding
->scope
->kind
!= sk_class
479 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
480 /* If either type involves template parameters, we must
481 wait until instantiation. */
482 || uses_template_parms (TREE_TYPE (decl
))
483 || uses_template_parms (TREE_TYPE (bval
))))
484 /* We have two typedef-names, both naming the same type to have
485 the same name. In general, this is OK because of:
489 In a given scope, a typedef specifier can be used to redefine
490 the name of any type declared in that scope to refer to the
491 type to which it already refers.
493 However, in class scopes, this rule does not apply due to the
494 stricter language in [class.mem] prohibiting redeclarations of
497 /* There can be two block-scope declarations of the same variable,
498 so long as they are `extern' declarations. However, there cannot
499 be two declarations of the same static data member:
503 A member shall not be declared twice in the
504 member-specification. */
505 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
506 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
507 && !DECL_CLASS_SCOPE_P (decl
))
509 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
512 else if (TREE_CODE (decl
) == NAMESPACE_DECL
513 && TREE_CODE (bval
) == NAMESPACE_DECL
514 && DECL_NAMESPACE_ALIAS (decl
)
515 && DECL_NAMESPACE_ALIAS (bval
)
516 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
519 In a declarative region, a namespace-alias-definition can be
520 used to redefine a namespace-alias declared in that declarative
521 region to refer only to the namespace to which it already
526 error ("declaration of %q#D", decl
);
527 error ("conflicts with previous declaration %q+#D", bval
);
531 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
534 /* Add DECL to the list of things declared in B. */
537 add_decl_to_level (tree decl
, cxx_scope
*b
)
539 /* We used to record virtual tables as if they were ordinary
540 variables, but no longer do so. */
541 gcc_assert (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
)));
543 if (TREE_CODE (decl
) == NAMESPACE_DECL
544 && !DECL_NAMESPACE_ALIAS (decl
))
546 TREE_CHAIN (decl
) = b
->namespaces
;
547 b
->namespaces
= decl
;
551 /* We build up the list in reverse order, and reverse it later if
553 TREE_CHAIN (decl
) = b
->names
;
557 /* If appropriate, add decl to separate list of statics. We
558 include extern variables because they might turn out to be
559 static later. It's OK for this list to contain a few false
561 if (b
->kind
== sk_namespace
)
562 if ((TREE_CODE (decl
) == VAR_DECL
563 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
564 || (TREE_CODE (decl
) == FUNCTION_DECL
565 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
566 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
570 /* Record a decl-node X as belonging to the current lexical scope.
571 Check for errors (such as an incompatible declaration for the same
572 name already seen in the same scope). IS_FRIEND is true if X is
573 declared as a friend.
575 Returns either X or an old decl for the same name.
576 If an old decl is returned, it may have been smashed
577 to agree with what X says. */
580 pushdecl_maybe_friend (tree x
, bool is_friend
)
584 int need_new_binding
;
586 timevar_push (TV_NAME_LOOKUP
);
588 if (x
== error_mark_node
)
589 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
591 need_new_binding
= 1;
593 if (DECL_TEMPLATE_PARM_P (x
))
594 /* Template parameters have no context; they are not X::T even
595 when declared within a class or namespace. */
599 if (current_function_decl
&& x
!= current_function_decl
600 /* A local declaration for a function doesn't constitute
602 && TREE_CODE (x
) != FUNCTION_DECL
603 /* A local declaration for an `extern' variable is in the
604 scope of the current namespace, not the current
606 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
607 /* When parsing the parameter list of a function declarator,
608 don't set DECL_CONTEXT to an enclosing function. When we
609 push the PARM_DECLs in order to process the function body,
610 current_binding_level->this_entity will be set. */
611 && !(TREE_CODE (x
) == PARM_DECL
612 && current_binding_level
->kind
== sk_function_parms
613 && current_binding_level
->this_entity
== NULL
)
614 && !DECL_CONTEXT (x
))
615 DECL_CONTEXT (x
) = current_function_decl
;
617 /* If this is the declaration for a namespace-scope function,
618 but the declaration itself is in a local scope, mark the
620 if (TREE_CODE (x
) == FUNCTION_DECL
621 && DECL_NAMESPACE_SCOPE_P (x
)
622 && current_function_decl
623 && x
!= current_function_decl
)
624 DECL_LOCAL_FUNCTION_P (x
) = 1;
627 name
= DECL_NAME (x
);
630 int different_binding_level
= 0;
632 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
633 name
= TREE_OPERAND (name
, 0);
635 /* In case this decl was explicitly namespace-qualified, look it
636 up in its namespace context. */
637 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
638 t
= namespace_binding (name
, DECL_CONTEXT (x
));
640 t
= lookup_name_innermost_nonclass_level (name
);
642 /* [basic.link] If there is a visible declaration of an entity
643 with linkage having the same name and type, ignoring entities
644 declared outside the innermost enclosing namespace scope, the
645 block scope declaration declares that same entity and
646 receives the linkage of the previous declaration. */
647 if (! t
&& current_function_decl
&& x
!= current_function_decl
648 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
649 && DECL_EXTERNAL (x
))
651 /* Look in block scope. */
652 t
= innermost_non_namespace_value (name
);
653 /* Or in the innermost namespace. */
655 t
= namespace_binding (name
, DECL_CONTEXT (x
));
656 /* Does it have linkage? Note that if this isn't a DECL, it's an
657 OVERLOAD, which is OK. */
658 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
661 different_binding_level
= 1;
664 /* If we are declaring a function, and the result of name-lookup
665 was an OVERLOAD, look for an overloaded instance that is
666 actually the same as the function we are declaring. (If
667 there is one, we have to merge our declaration with the
668 previous declaration.) */
669 if (t
&& TREE_CODE (t
) == OVERLOAD
)
673 if (TREE_CODE (x
) == FUNCTION_DECL
)
674 for (match
= t
; match
; match
= OVL_NEXT (match
))
676 if (decls_match (OVL_CURRENT (match
), x
))
680 /* Just choose one. */
684 t
= OVL_CURRENT (match
);
689 if (t
&& t
!= error_mark_node
)
691 if (different_binding_level
)
693 if (decls_match (x
, t
))
694 /* The standard only says that the local extern
695 inherits linkage from the previous decl; in
696 particular, default args are not shared. Add
697 the decl into a hash table to make sure only
698 the previous decl in this case is seen by the
701 struct cxx_int_tree_map
*h
;
704 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
706 if (cp_function_chain
->extern_decl_map
== NULL
)
707 cp_function_chain
->extern_decl_map
708 = htab_create_ggc (20, cxx_int_tree_map_hash
,
709 cxx_int_tree_map_eq
, NULL
);
711 h
= GGC_NEW (struct cxx_int_tree_map
);
712 h
->uid
= DECL_UID (x
);
714 loc
= htab_find_slot_with_hash
715 (cp_function_chain
->extern_decl_map
, h
,
717 *(struct cxx_int_tree_map
**) loc
= h
;
720 else if (TREE_CODE (t
) == PARM_DECL
)
722 /* Check for duplicate params. */
723 tree d
= duplicate_decls (x
, t
, is_friend
);
725 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, d
);
727 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
728 || DECL_FUNCTION_TEMPLATE_P (x
))
729 && is_overloaded_fn (t
))
730 /* Don't do anything just yet. */;
731 else if (t
== wchar_decl_node
)
733 if (! DECL_IN_SYSTEM_HEADER (x
))
734 pedwarn (input_location
, OPT_pedantic
, "redeclaration of %<wchar_t%> as %qT",
737 /* Throw away the redeclaration. */
738 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
742 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
744 /* If the redeclaration failed, we can stop at this
746 if (olddecl
== error_mark_node
)
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
751 if (TREE_CODE (t
) == TYPE_DECL
)
752 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
754 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
756 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
758 /* A redeclaration of main, but not a duplicate of the
763 This function shall not be overloaded. */
764 error ("invalid redeclaration of %q+D", t
);
766 /* We don't try to push this declaration since that
768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
773 /* If x has C linkage-specification, (extern "C"),
774 lookup its binding, in case it's already bound to an object.
775 The lookup is done in all namespaces.
776 If we find an existing binding, make sure it has the same
777 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
778 if ((TREE_CODE (x
) == FUNCTION_DECL
)
779 && DECL_EXTERN_C_P (x
)
780 /* We should ignore declarations happening in system headers. */
781 && !DECL_IN_SYSTEM_HEADER (x
))
783 cxx_binding
*function_binding
=
784 lookup_extern_c_fun_binding_in_all_ns (x
);
786 && !DECL_IN_SYSTEM_HEADER (function_binding
->value
))
788 tree previous
= function_binding
->value
;
790 /* In case either x or previous is declared to throw an exception,
791 make sure both exception specifications are equal. */
792 if (decls_match (x
, previous
))
794 tree x_exception_spec
= NULL_TREE
;
795 tree previous_exception_spec
= NULL_TREE
;
798 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
799 previous_exception_spec
=
800 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
801 if (!comp_except_specs (previous_exception_spec
,
805 pedwarn (input_location
, 0, "declaration of %q#D with C language linkage",
807 pedwarn (input_location
, 0, "conflicts with previous declaration %q+#D",
809 pedwarn (input_location
, 0, "due to different exception specifications");
810 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
816 if (TREE_CODE (x
) == FUNCTION_DECL
|| DECL_FUNCTION_TEMPLATE_P (x
))
817 check_default_args (x
);
819 check_template_shadow (x
);
821 /* If this is a function conjured up by the back end, massage it
822 so it looks friendly. */
823 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
825 retrofit_lang_decl (x
);
826 SET_DECL_LANGUAGE (x
, lang_c
);
829 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
831 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
833 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
834 if (!namespace_bindings_p ())
835 /* We do not need to create a binding for this name;
836 push_overloaded_decl will have already done so if
838 need_new_binding
= 0;
840 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
842 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
844 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
845 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
848 /* If declaring a type as a typedef, copy the type (unless we're
849 at line 0), and install this TYPE_DECL as the new type's typedef
850 name. See the extensive comment in ../c-decl.c (pushdecl). */
851 if (TREE_CODE (x
) == TYPE_DECL
)
853 tree type
= TREE_TYPE (x
);
854 if (DECL_IS_BUILTIN (x
))
856 if (TYPE_NAME (type
) == 0)
857 TYPE_NAME (type
) = x
;
859 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
860 /* We don't want to copy the type when all we're
861 doing is making a TYPE_DECL for the purposes of
863 && (!TYPE_NAME (type
)
864 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
866 DECL_ORIGINAL_TYPE (x
) = type
;
867 type
= build_variant_type_copy (type
);
868 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
869 TYPE_NAME (type
) = x
;
870 TREE_TYPE (x
) = type
;
873 if (type
!= error_mark_node
875 && TYPE_IDENTIFIER (type
))
876 set_identifier_type_value (DECL_NAME (x
), x
);
879 /* Multiple external decls of the same identifier ought to match.
881 We get warnings about inline functions where they are defined.
882 We get warnings about other functions from push_overloaded_decl.
884 Avoid duplicate warnings where they are used. */
885 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
889 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
890 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
891 decl
= OVL_FUNCTION (decl
);
893 if (decl
&& decl
!= error_mark_node
894 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
895 /* If different sort of thing, we already gave an error. */
896 && TREE_CODE (decl
) == TREE_CODE (x
)
897 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
899 permerror (input_location
, "type mismatch with previous external decl of %q#D", x
);
900 permerror (input_location
, "previous external decl of %q+#D", decl
);
904 if (TREE_CODE (x
) == FUNCTION_DECL
906 && !flag_friend_injection
)
908 /* This is a new declaration of a friend function, so hide
909 it from ordinary function lookup. */
910 DECL_ANTICIPATED (x
) = 1;
911 DECL_HIDDEN_FRIEND_P (x
) = 1;
914 /* This name is new in its binding level.
915 Install the new declaration and return it. */
916 if (namespace_bindings_p ())
918 /* Install a global value. */
920 /* If the first global decl has external linkage,
921 warn if we later see static one. */
922 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
923 TREE_PUBLIC (name
) = 1;
925 /* Bind the name for the entity. */
926 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
928 && (TREE_CODE (x
) == TYPE_DECL
929 || TREE_CODE (x
) == VAR_DECL
930 || TREE_CODE (x
) == NAMESPACE_DECL
931 || TREE_CODE (x
) == CONST_DECL
932 || TREE_CODE (x
) == TEMPLATE_DECL
))
933 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
935 /* If new decl is `static' and an `extern' was seen previously,
937 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
938 warn_extern_redeclared_static (x
, t
);
942 /* Here to install a non-global value. */
943 tree oldlocal
= innermost_non_namespace_value (name
);
944 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
946 if (need_new_binding
)
948 push_local_binding (name
, x
, 0);
949 /* Because push_local_binding will hook X on to the
950 current_binding_level's name list, we don't want to
951 do that again below. */
952 need_new_binding
= 0;
955 /* If this is a TYPE_DECL, push it into the type value slot. */
956 if (TREE_CODE (x
) == TYPE_DECL
)
957 set_identifier_type_value (name
, x
);
959 /* Clear out any TYPE_DECL shadowed by a namespace so that
960 we won't think this is a type. The C struct hack doesn't
961 go through namespaces. */
962 if (TREE_CODE (x
) == NAMESPACE_DECL
)
963 set_identifier_type_value (name
, NULL_TREE
);
970 && TREE_CODE (oldlocal
) == VAR_DECL
971 && DECL_DEAD_FOR_LOCAL (oldlocal
))
972 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
974 if (oldlocal
== NULL_TREE
)
975 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
978 /* If this is an extern function declaration, see if we
979 have a global definition or declaration for the function. */
980 if (oldlocal
== NULL_TREE
982 && oldglobal
!= NULL_TREE
983 && TREE_CODE (x
) == FUNCTION_DECL
984 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
986 /* We have one. Their types must agree. */
987 if (decls_match (x
, oldglobal
))
991 warning (0, "extern declaration of %q#D doesn't match", x
);
992 warning (0, "global declaration %q+#D", oldglobal
);
995 /* If we have a local external declaration,
996 and no file-scope declaration has yet been seen,
997 then if we later have a file-scope decl it must not be static. */
998 if (oldlocal
== NULL_TREE
999 && oldglobal
== NULL_TREE
1000 && DECL_EXTERNAL (x
)
1002 TREE_PUBLIC (name
) = 1;
1004 /* Warn if shadowing an argument at the top level of the body. */
1005 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1006 /* Inline decls shadow nothing. */
1007 && !DECL_FROM_INLINE (x
)
1008 && TREE_CODE (oldlocal
) == PARM_DECL
1009 /* Don't check the `this' parameter. */
1010 && !DECL_ARTIFICIAL (oldlocal
))
1014 /* Don't complain if it's from an enclosing function. */
1015 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1016 && TREE_CODE (x
) != PARM_DECL
)
1018 /* Go to where the parms should be and see if we find
1020 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
1022 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1023 /* Skip the ctor/dtor cleanup level. */
1027 if (b
->kind
== sk_function_parms
)
1029 error ("declaration of %q#D shadows a parameter", x
);
1034 if (warn_shadow
&& !err
)
1036 warning (OPT_Wshadow
, "declaration of %q#D shadows a parameter", x
);
1037 warning (OPT_Wshadow
, "%Jshadowed declaration is here", oldlocal
);
1041 /* Maybe warn if shadowing something else. */
1042 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1043 /* No shadow warnings for internally generated vars. */
1044 && ! DECL_ARTIFICIAL (x
)
1045 /* No shadow warnings for vars made for inlining. */
1046 && ! DECL_FROM_INLINE (x
))
1050 if (current_class_ptr
)
1051 member
= lookup_member (current_class_type
,
1054 /*want_type=*/false);
1058 if (member
&& !TREE_STATIC (member
))
1060 /* Location of previous decl is not useful in this case. */
1061 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
1064 else if (oldlocal
!= NULL_TREE
1065 && TREE_CODE (oldlocal
) == VAR_DECL
)
1067 warning (OPT_Wshadow
, "declaration of %qD shadows a previous local", x
);
1068 warning (OPT_Wshadow
, "%Jshadowed declaration is here", oldlocal
);
1070 else if (oldglobal
!= NULL_TREE
1071 && TREE_CODE (oldglobal
) == VAR_DECL
)
1072 /* XXX shadow warnings in outer-more namespaces */
1074 warning (OPT_Wshadow
, "declaration of %qD shadows a global declaration",
1076 warning (OPT_Wshadow
, "%Jshadowed declaration is here", oldglobal
);
1081 if (TREE_CODE (x
) == VAR_DECL
)
1082 maybe_register_incomplete_var (x
);
1085 if (need_new_binding
)
1086 add_decl_to_level (x
,
1087 DECL_NAMESPACE_SCOPE_P (x
)
1088 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1089 : current_binding_level
);
1091 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1094 /* Record a decl-node X as belonging to the current lexical scope. */
1099 return pushdecl_maybe_friend (x
, false);
1102 /* Enter DECL into the symbol table, if that's appropriate. Returns
1103 DECL, or a modified version thereof. */
1106 maybe_push_decl (tree decl
)
1108 tree type
= TREE_TYPE (decl
);
1110 /* Add this decl to the current binding level, but not if it comes
1111 from another scope, e.g. a static member variable. TEM may equal
1112 DECL or it may be a previous decl of the same name. */
1113 if (decl
== error_mark_node
1114 || (TREE_CODE (decl
) != PARM_DECL
1115 && DECL_CONTEXT (decl
) != NULL_TREE
1116 /* Definitions of namespace members outside their namespace are
1118 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
1119 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1120 || TREE_CODE (type
) == UNKNOWN_TYPE
1121 /* The declaration of a template specialization does not affect
1122 the functions available for overload resolution, so we do not
1124 || (TREE_CODE (decl
) == FUNCTION_DECL
1125 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1128 return pushdecl (decl
);
1131 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1132 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1133 doesn't really belong to this binding level, that it got here
1134 through a using-declaration. */
1137 push_local_binding (tree id
, tree decl
, int flags
)
1139 struct cp_binding_level
*b
;
1141 /* Skip over any local classes. This makes sense if we call
1142 push_local_binding with a friend decl of a local class. */
1143 b
= innermost_nonclass_level ();
1145 if (lookup_name_innermost_nonclass_level (id
))
1147 /* Supplement the existing binding. */
1148 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1149 /* It didn't work. Something else must be bound at this
1150 level. Do not add DECL to the list of things to pop
1155 /* Create a new binding. */
1156 push_binding (id
, decl
, b
);
1158 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1159 /* We must put the OVERLOAD into a TREE_LIST since the
1160 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1161 decls that got here through a using-declaration. */
1162 decl
= build_tree_list (NULL_TREE
, decl
);
1164 /* And put DECL on the list of things declared by the current
1166 add_decl_to_level (decl
, b
);
1169 /* Check to see whether or not DECL is a variable that would have been
1170 in scope under the ARM, but is not in scope under the ANSI/ISO
1171 standard. If so, issue an error message. If name lookup would
1172 work in both cases, but return a different result, this function
1173 returns the result of ANSI/ISO lookup. Otherwise, it returns
1177 check_for_out_of_scope_variable (tree decl
)
1181 /* We only care about out of scope variables. */
1182 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1185 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1186 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1187 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1188 && DECL_DEAD_FOR_LOCAL (shadowed
))
1189 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1190 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1192 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1195 if (!DECL_ERROR_REPORTED (decl
))
1197 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1198 warning (0, " matches this %q+D under ISO standard rules",
1200 warning (0, " matches this %q+D under old rules", decl
);
1201 DECL_ERROR_REPORTED (decl
) = 1;
1206 /* If we have already complained about this declaration, there's no
1207 need to do it again. */
1208 if (DECL_ERROR_REPORTED (decl
))
1211 DECL_ERROR_REPORTED (decl
) = 1;
1213 if (TREE_TYPE (decl
) == error_mark_node
)
1216 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1218 error ("name lookup of %qD changed for ISO %<for%> scoping",
1220 error (" cannot use obsolete binding at %q+D because "
1221 "it has a destructor", decl
);
1222 return error_mark_node
;
1226 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1228 if (flag_permissive
)
1229 permerror (input_location
, " using obsolete binding at %q+D", decl
);
1235 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1244 /* true means unconditionally make a BLOCK for the next level pushed. */
1246 static bool keep_next_level_flag
;
1248 static int binding_depth
= 0;
1249 static int is_class_level
= 0;
1256 for (i
= 0; i
< depth
* 2; i
++)
1260 /* Return a string describing the kind of SCOPE we have. */
1262 cxx_scope_descriptor (cxx_scope
*scope
)
1264 /* The order of this table must match the "scope_kind"
1266 static const char* scope_kind_names
[] = {
1272 "function-parameter-scope",
1275 "template-parameter-scope",
1276 "template-explicit-spec-scope"
1278 const scope_kind kind
= scope
->explicit_spec_p
1279 ? sk_template_spec
: scope
->kind
;
1281 return scope_kind_names
[kind
];
1284 /* Output a debugging information about SCOPE when performing
1287 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1289 const char *desc
= cxx_scope_descriptor (scope
);
1290 if (scope
->this_entity
)
1291 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1292 scope
->this_entity
, (void *) scope
, line
);
1294 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1297 /* Return the estimated initial size of the hashtable of a NAMESPACE
1300 static inline size_t
1301 namespace_scope_ht_size (tree ns
)
1303 tree name
= DECL_NAME (ns
);
1305 return name
== std_identifier
1306 ? NAMESPACE_STD_HT_SIZE
1307 : (name
== global_scope_name
1308 ? GLOBAL_SCOPE_HT_SIZE
1309 : NAMESPACE_ORDINARY_HT_SIZE
);
1312 /* A chain of binding_level structures awaiting reuse. */
1314 static GTY((deletable
)) struct cp_binding_level
*free_binding_level
;
1316 /* Insert SCOPE as the innermost binding level. */
1319 push_binding_level (struct cp_binding_level
*scope
)
1321 /* Add it to the front of currently active scopes stack. */
1322 scope
->level_chain
= current_binding_level
;
1323 current_binding_level
= scope
;
1324 keep_next_level_flag
= false;
1326 if (ENABLE_SCOPE_CHECKING
)
1328 scope
->binding_depth
= binding_depth
;
1329 indent (binding_depth
);
1330 cxx_scope_debug (scope
, input_line
, "push");
1336 /* Create a new KIND scope and make it the top of the active scopes stack.
1337 ENTITY is the scope of the associated C++ entity (namespace, class,
1338 function, C++0x enumeration); it is NULL otherwise. */
1341 begin_scope (scope_kind kind
, tree entity
)
1345 /* Reuse or create a struct for this binding level. */
1346 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1348 scope
= free_binding_level
;
1349 memset (scope
, 0, sizeof (cxx_scope
));
1350 free_binding_level
= scope
->level_chain
;
1353 scope
= GGC_CNEW (cxx_scope
);
1355 scope
->this_entity
= entity
;
1356 scope
->more_cleanups_ok
= true;
1363 case sk_template_spec
:
1364 scope
->explicit_spec_p
= true;
1365 kind
= sk_template_parms
;
1367 case sk_template_parms
:
1373 case sk_scoped_enum
:
1374 case sk_function_parms
:
1376 scope
->keep
= keep_next_level_flag
;
1380 NAMESPACE_LEVEL (entity
) = scope
;
1381 scope
->static_decls
=
1382 VEC_alloc (tree
, gc
,
1383 DECL_NAME (entity
) == std_identifier
1384 || DECL_NAME (entity
) == global_scope_name
1389 /* Should not happen. */
1395 push_binding_level (scope
);
1400 /* We're about to leave current scope. Pop the top of the stack of
1401 currently active scopes. Return the enclosing scope, now active. */
1406 cxx_scope
*scope
= current_binding_level
;
1408 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1409 current_binding_level
= class_binding_level
;
1411 /* We cannot leave a scope, if there are none left. */
1412 if (NAMESPACE_LEVEL (global_namespace
))
1413 gcc_assert (!global_scope_p (scope
));
1415 if (ENABLE_SCOPE_CHECKING
)
1417 indent (--binding_depth
);
1418 cxx_scope_debug (scope
, input_line
, "leave");
1419 if (is_class_level
!= (scope
== class_binding_level
))
1421 indent (binding_depth
);
1422 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1427 /* Move one nesting level up. */
1428 current_binding_level
= scope
->level_chain
;
1430 /* Namespace-scopes are left most probably temporarily, not
1431 completely; they can be reopened later, e.g. in namespace-extension
1432 or any name binding activity that requires us to resume a
1433 namespace. For classes, we cache some binding levels. For other
1434 scopes, we just make the structure available for reuse. */
1435 if (scope
->kind
!= sk_namespace
1436 && scope
->kind
!= sk_class
)
1438 scope
->level_chain
= free_binding_level
;
1439 gcc_assert (!ENABLE_SCOPE_CHECKING
1440 || scope
->binding_depth
== binding_depth
);
1441 free_binding_level
= scope
;
1444 /* Find the innermost enclosing class scope, and reset
1445 CLASS_BINDING_LEVEL appropriately. */
1446 if (scope
->kind
== sk_class
)
1448 class_binding_level
= NULL
;
1449 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1450 if (scope
->kind
== sk_class
)
1452 class_binding_level
= scope
;
1457 return current_binding_level
;
1461 resume_scope (struct cp_binding_level
* b
)
1463 /* Resuming binding levels is meant only for namespaces,
1464 and those cannot nest into classes. */
1465 gcc_assert (!class_binding_level
);
1466 /* Also, resuming a non-directly nested namespace is a no-no. */
1467 gcc_assert (b
->level_chain
== current_binding_level
);
1468 current_binding_level
= b
;
1469 if (ENABLE_SCOPE_CHECKING
)
1471 b
->binding_depth
= binding_depth
;
1472 indent (binding_depth
);
1473 cxx_scope_debug (b
, input_line
, "resume");
1479 /* Return the innermost binding level that is not for a class scope. */
1482 innermost_nonclass_level (void)
1486 b
= current_binding_level
;
1487 while (b
->kind
== sk_class
)
1493 /* We're defining an object of type TYPE. If it needs a cleanup, but
1494 we're not allowed to add any more objects with cleanups to the current
1495 scope, create a new binding level. */
1498 maybe_push_cleanup_level (tree type
)
1500 if (type
!= error_mark_node
1501 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1502 && current_binding_level
->more_cleanups_ok
== 0)
1504 begin_scope (sk_cleanup
, NULL
);
1505 current_binding_level
->statement_list
= push_stmt_list ();
1509 /* Nonzero if we are currently in the global binding level. */
1512 global_bindings_p (void)
1514 return global_scope_p (current_binding_level
);
1517 /* True if we are currently in a toplevel binding level. This
1518 means either the global binding level or a namespace in a toplevel
1519 binding level. Since there are no non-toplevel namespace levels,
1520 this really means any namespace or template parameter level. We
1521 also include a class whose context is toplevel. */
1524 toplevel_bindings_p (void)
1526 struct cp_binding_level
*b
= innermost_nonclass_level ();
1528 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1531 /* True if this is a namespace scope, or if we are defining a class
1532 which is itself at namespace scope, or whose enclosing class is
1533 such a class, etc. */
1536 namespace_bindings_p (void)
1538 struct cp_binding_level
*b
= innermost_nonclass_level ();
1540 return b
->kind
== sk_namespace
;
1543 /* True if the current level needs to have a BLOCK made. */
1548 return (current_binding_level
->blocks
!= NULL_TREE
1549 || current_binding_level
->keep
1550 || current_binding_level
->kind
== sk_cleanup
1551 || current_binding_level
->names
!= NULL_TREE
1552 || current_binding_level
->using_directives
);
1555 /* Returns the kind of the innermost scope. */
1558 innermost_scope_kind (void)
1560 return current_binding_level
->kind
;
1563 /* Returns true if this scope was created to store template parameters. */
1566 template_parm_scope_p (void)
1568 return innermost_scope_kind () == sk_template_parms
;
1571 /* If KEEP is true, make a BLOCK node for the next binding level,
1572 unconditionally. Otherwise, use the normal logic to decide whether
1573 or not to create a BLOCK. */
1576 keep_next_level (bool keep
)
1578 keep_next_level_flag
= keep
;
1581 /* Return the list of declarations of the current level.
1582 Note that this list is in reverse order unless/until
1583 you nreverse it; and when you do nreverse it, you must
1584 store the result back using `storedecls' or you will lose. */
1589 return current_binding_level
->names
;
1592 /* For debugging. */
1593 static int no_print_functions
= 0;
1594 static int no_print_builtins
= 0;
1597 print_binding_level (struct cp_binding_level
* lvl
)
1601 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1602 if (lvl
->more_cleanups_ok
)
1603 fprintf (stderr
, " more-cleanups-ok");
1604 if (lvl
->have_cleanups
)
1605 fprintf (stderr
, " have-cleanups");
1606 fprintf (stderr
, "\n");
1609 fprintf (stderr
, " names:\t");
1610 /* We can probably fit 3 names to a line? */
1611 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1613 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1615 if (no_print_builtins
1616 && (TREE_CODE (t
) == TYPE_DECL
)
1617 && DECL_IS_BUILTIN (t
))
1620 /* Function decls tend to have longer names. */
1621 if (TREE_CODE (t
) == FUNCTION_DECL
)
1628 fprintf (stderr
, "\n\t");
1631 print_node_brief (stderr
, "", t
, 0);
1632 if (t
== error_mark_node
)
1636 fprintf (stderr
, "\n");
1638 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1641 cp_class_binding
*b
;
1642 fprintf (stderr
, " class-shadowed:");
1644 VEC_iterate(cp_class_binding
, lvl
->class_shadowed
, i
, b
);
1646 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1647 fprintf (stderr
, "\n");
1649 if (lvl
->type_shadowed
)
1651 fprintf (stderr
, " type-shadowed:");
1652 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1654 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1656 fprintf (stderr
, "\n");
1661 print_other_binding_stack (struct cp_binding_level
*stack
)
1663 struct cp_binding_level
*level
;
1664 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1666 fprintf (stderr
, "binding level %p\n", (void *) level
);
1667 print_binding_level (level
);
1672 print_binding_stack (void)
1674 struct cp_binding_level
*b
;
1675 fprintf (stderr
, "current_binding_level=%p\n"
1676 "class_binding_level=%p\n"
1677 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1678 (void *) current_binding_level
, (void *) class_binding_level
,
1679 (void *) NAMESPACE_LEVEL (global_namespace
));
1680 if (class_binding_level
)
1682 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1683 if (b
== current_binding_level
)
1686 b
= class_binding_level
;
1688 b
= current_binding_level
;
1691 b
= current_binding_level
;
1692 print_other_binding_stack (b
);
1693 fprintf (stderr
, "global:\n");
1694 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1697 /* Return the type associated with id. */
1700 identifier_type_value (tree id
)
1702 timevar_push (TV_NAME_LOOKUP
);
1703 /* There is no type with that name, anywhere. */
1704 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1706 /* This is not the type marker, but the real thing. */
1707 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1708 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, REAL_IDENTIFIER_TYPE_VALUE (id
));
1709 /* Have to search for it. It must be on the global level, now.
1710 Ask lookup_name not to return non-types. */
1711 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1713 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, TREE_TYPE (id
));
1714 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1717 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1718 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1721 identifier_global_value (tree t
)
1723 return IDENTIFIER_GLOBAL_VALUE (t
);
1726 /* Push a definition of struct, union or enum tag named ID. into
1727 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1728 the tag ID is not already defined. */
1731 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1735 if (b
->kind
!= sk_namespace
)
1737 /* Shadow the marker, not the real thing, so that the marker
1738 gets restored later. */
1739 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1741 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1742 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1743 TREE_TYPE (b
->type_shadowed
) = type
;
1747 cxx_binding
*binding
=
1748 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1751 supplement_binding (binding
, decl
);
1753 binding
->value
= decl
;
1755 /* Store marker instead of real type. */
1756 type
= global_type_node
;
1758 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1761 /* As set_identifier_type_value_with_scope, but using
1762 current_binding_level. */
1765 set_identifier_type_value (tree id
, tree decl
)
1767 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1770 /* Return the name for the constructor (or destructor) for the
1771 specified class TYPE. When given a template, this routine doesn't
1772 lose the specialization. */
1775 constructor_name_full (tree type
)
1777 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1780 /* Return the name for the constructor (or destructor) for the
1781 specified class. When given a template, return the plain
1782 unspecialized name. */
1785 constructor_name (tree type
)
1788 name
= constructor_name_full (type
);
1789 if (IDENTIFIER_TEMPLATE (name
))
1790 name
= IDENTIFIER_TEMPLATE (name
);
1794 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1795 which must be a class type. */
1798 constructor_name_p (tree name
, tree type
)
1802 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
1807 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1810 ctor_name
= constructor_name_full (type
);
1811 if (name
== ctor_name
)
1813 if (IDENTIFIER_TEMPLATE (ctor_name
)
1814 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1819 /* Counter used to create anonymous type names. */
1821 static GTY(()) int anon_cnt
;
1823 /* Return an IDENTIFIER which can be used as a name for
1824 anonymous structs and unions. */
1827 make_anon_name (void)
1831 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1832 return get_identifier (buf
);
1835 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1837 static inline cxx_binding
*
1838 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1840 timevar_push (TV_NAME_LOOKUP
);
1842 for (; binding
!= NULL
; binding
= binding
->previous
)
1843 if (binding
->scope
== scope
)
1844 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
);
1846 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, (cxx_binding
*)0);
1849 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1851 static inline cxx_binding
*
1852 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1854 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1857 /* Fold-in case where NAME is used only once. */
1858 if (scope
== b
->scope
&& b
->previous
== NULL
)
1860 return find_binding (scope
, b
);
1865 /* Always returns a binding for name in scope. If no binding is
1866 found, make a new one. */
1868 static cxx_binding
*
1869 binding_for_name (cxx_scope
*scope
, tree name
)
1871 cxx_binding
*result
;
1873 result
= cxx_scope_find_binding_for_name (scope
, name
);
1876 /* Not found, make a new one. */
1877 result
= cxx_binding_make (NULL
, NULL
);
1878 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1879 result
->scope
= scope
;
1880 result
->is_local
= false;
1881 result
->value_is_inherited
= false;
1882 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1886 /* Walk through the bindings associated to the name of FUNCTION,
1887 and return the first binding that declares a function with a
1888 "C" linkage specification, a.k.a 'extern "C"'.
1889 This function looks for the binding, regardless of which scope it
1890 has been defined in. It basically looks in all the known scopes.
1891 Note that this function does not lookup for bindings of builtin functions
1892 or for functions declared in system headers. */
1894 lookup_extern_c_fun_binding_in_all_ns (tree function
)
1899 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
1901 name
= DECL_NAME (function
);
1902 gcc_assert (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
);
1904 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1906 iter
= iter
->previous
)
1909 && TREE_CODE (iter
->value
) == FUNCTION_DECL
1910 && DECL_EXTERN_C_P (iter
->value
)
1911 && !DECL_ARTIFICIAL (iter
->value
))
1919 /* Insert another USING_DECL into the current binding level, returning
1920 this declaration. If this is a redeclaration, do nothing, and
1921 return NULL_TREE if this not in namespace scope (in namespace
1922 scope, a using decl might extend any previous bindings). */
1925 push_using_decl (tree scope
, tree name
)
1929 timevar_push (TV_NAME_LOOKUP
);
1930 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
1931 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1932 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
1933 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
1936 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
1937 namespace_bindings_p () ? decl
: NULL_TREE
);
1938 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
1939 USING_DECL_SCOPE (decl
) = scope
;
1940 TREE_CHAIN (decl
) = current_binding_level
->usings
;
1941 current_binding_level
->usings
= decl
;
1942 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1945 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1946 caller to set DECL_CONTEXT properly. */
1949 pushdecl_with_scope (tree x
, cxx_scope
*level
, bool is_friend
)
1951 struct cp_binding_level
*b
;
1952 tree function_decl
= current_function_decl
;
1954 timevar_push (TV_NAME_LOOKUP
);
1955 current_function_decl
= NULL_TREE
;
1956 if (level
->kind
== sk_class
)
1958 b
= class_binding_level
;
1959 class_binding_level
= level
;
1960 pushdecl_class_level (x
);
1961 class_binding_level
= b
;
1965 b
= current_binding_level
;
1966 current_binding_level
= level
;
1967 x
= pushdecl_maybe_friend (x
, is_friend
);
1968 current_binding_level
= b
;
1970 current_function_decl
= function_decl
;
1971 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1974 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1975 other definitions already in place. We get around this by making
1976 the value of the identifier point to a list of all the things that
1977 want to be referenced by that name. It is then up to the users of
1978 that name to decide what to do with that list.
1980 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1981 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1983 FLAGS is a bitwise-or of the following values:
1984 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1986 PUSH_USING: DECL is being pushed as the result of a using
1989 IS_FRIEND is true if this is a friend declaration.
1991 The value returned may be a previous declaration if we guessed wrong
1992 about what language DECL should belong to (C or C++). Otherwise,
1993 it's always DECL (and never something that's not a _DECL). */
1996 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
1998 tree name
= DECL_NAME (decl
);
2001 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2003 timevar_push (TV_NAME_LOOKUP
);
2005 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2007 old
= lookup_name_innermost_nonclass_level (name
);
2011 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2013 tree t
= TREE_TYPE (old
);
2014 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2015 && (! DECL_IN_SYSTEM_HEADER (decl
)
2016 || ! DECL_IN_SYSTEM_HEADER (old
)))
2017 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2020 else if (is_overloaded_fn (old
))
2024 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2026 tree fn
= OVL_CURRENT (tmp
);
2029 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2030 && !(flags
& PUSH_USING
)
2031 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2032 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
2033 && ! decls_match (fn
, decl
))
2034 error ("%q#D conflicts with previous using declaration %q#D",
2037 dup
= duplicate_decls (decl
, fn
, is_friend
);
2038 /* If DECL was a redeclaration of FN -- even an invalid
2039 one -- pass that information along to our caller. */
2040 if (dup
== fn
|| dup
== error_mark_node
)
2041 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, dup
);
2044 /* We don't overload implicit built-ins. duplicate_decls()
2045 may fail to merge the decls if the new decl is e.g. a
2046 template function. */
2047 if (TREE_CODE (old
) == FUNCTION_DECL
2048 && DECL_ANTICIPATED (old
)
2049 && !DECL_HIDDEN_FRIEND_P (old
))
2052 else if (old
== error_mark_node
)
2053 /* Ignore the undefined symbol marker. */
2057 error ("previous non-function declaration %q+#D", old
);
2058 error ("conflicts with function declaration %q#D", decl
);
2059 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2063 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2064 /* If it's a using declaration, we always need to build an OVERLOAD,
2065 because it's the only way to remember that the declaration comes
2066 from 'using', and have the lookup behave correctly. */
2067 || (flags
& PUSH_USING
))
2069 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2070 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2072 new_binding
= ovl_cons (decl
, old
);
2073 if (flags
& PUSH_USING
)
2074 OVL_USED (new_binding
) = 1;
2077 /* NAME is not ambiguous. */
2081 set_namespace_binding (name
, current_namespace
, new_binding
);
2084 /* We only create an OVERLOAD if there was a previous binding at
2085 this level, or if decl is a template. In the former case, we
2086 need to remove the old binding and replace it with the new
2087 binding. We must also run through the NAMES on the binding
2088 level where the name was bound to update the chain. */
2090 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2094 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2096 d
= &TREE_CHAIN (*d
))
2098 || (TREE_CODE (*d
) == TREE_LIST
2099 && TREE_VALUE (*d
) == old
))
2101 if (TREE_CODE (*d
) == TREE_LIST
)
2102 /* Just replace the old binding with the new. */
2103 TREE_VALUE (*d
) = new_binding
;
2105 /* Build a TREE_LIST to wrap the OVERLOAD. */
2106 *d
= tree_cons (NULL_TREE
, new_binding
,
2109 /* And update the cxx_binding node. */
2110 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2111 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2114 /* We should always find a previous binding in this case. */
2118 /* Install the new binding. */
2119 push_local_binding (name
, new_binding
, flags
);
2122 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2125 /* Check a non-member using-declaration. Return the name and scope
2126 being used, and the USING_DECL, or NULL_TREE on failure. */
2129 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2131 /* [namespace.udecl]
2132 A using-declaration for a class member shall be a
2133 member-declaration. */
2136 error ("%qT is not a namespace", scope
);
2139 else if (scope
== error_mark_node
)
2142 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2145 A using-declaration shall not name a template-id. */
2146 error ("a using-declaration cannot specify a template-id. "
2147 "Try %<using %D%>", name
);
2151 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2153 error ("namespace %qD not allowed in using-declaration", decl
);
2157 if (TREE_CODE (decl
) == SCOPE_REF
)
2159 /* It's a nested name with template parameter dependent scope.
2160 This can only be using-declaration for class member. */
2161 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2165 if (is_overloaded_fn (decl
))
2166 decl
= get_first_fn (decl
);
2168 gcc_assert (DECL_P (decl
));
2170 /* Make a USING_DECL. */
2171 return push_using_decl (scope
, name
);
2174 /* Process local and global using-declarations. */
2177 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2178 tree
*newval
, tree
*newtype
)
2180 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2182 *newval
= *newtype
= NULL_TREE
;
2183 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2187 if (!decls
.value
&& !decls
.type
)
2189 error ("%qD not declared", name
);
2193 /* Shift the old and new bindings around so we're comparing class and
2194 enumeration names to each other. */
2195 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2201 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2203 decls
.type
= decls
.value
;
2204 decls
.value
= NULL_TREE
;
2207 /* It is impossible to overload a built-in function; any explicit
2208 declaration eliminates the built-in declaration. So, if OLDVAL
2209 is a built-in, then we can just pretend it isn't there. */
2211 && TREE_CODE (oldval
) == FUNCTION_DECL
2212 && DECL_ANTICIPATED (oldval
)
2213 && !DECL_HIDDEN_FRIEND_P (oldval
))
2218 /* Check for using functions. */
2219 if (is_overloaded_fn (decls
.value
))
2223 if (oldval
&& !is_overloaded_fn (oldval
))
2225 error ("%qD is already declared in this scope", name
);
2230 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2232 tree new_fn
= OVL_CURRENT (tmp
);
2234 /* [namespace.udecl]
2236 If a function declaration in namespace scope or block
2237 scope has the same name and the same parameter types as a
2238 function introduced by a using declaration the program is
2240 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2242 tree old_fn
= OVL_CURRENT (tmp1
);
2244 if (new_fn
== old_fn
)
2245 /* The function already exists in the current namespace. */
2247 else if (OVL_USED (tmp1
))
2248 continue; /* this is a using decl */
2249 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2250 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2252 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2253 || DECL_HIDDEN_FRIEND_P (old_fn
));
2255 /* There was already a non-using declaration in
2256 this scope with the same parameter types. If both
2257 are the same extern "C" functions, that's ok. */
2258 if (decls_match (new_fn
, old_fn
))
2262 error ("%qD is already declared in this scope", name
);
2268 /* If we broke out of the loop, there's no reason to add
2269 this function to the using declarations for this
2274 /* If we are adding to an existing OVERLOAD, then we no
2275 longer know the type of the set of functions. */
2276 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2277 TREE_TYPE (*newval
) = unknown_type_node
;
2278 /* Add this new function to the set. */
2279 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2280 /* If there is only one function, then we use its type. (A
2281 using-declaration naming a single function can be used in
2282 contexts where overload resolution cannot be
2284 if (TREE_CODE (*newval
) != OVERLOAD
)
2286 *newval
= ovl_cons (*newval
, NULL_TREE
);
2287 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2289 OVL_USED (*newval
) = 1;
2294 *newval
= decls
.value
;
2295 if (oldval
&& !decls_match (*newval
, oldval
))
2296 error ("%qD is already declared in this scope", name
);
2302 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2304 error ("reference to %qD is ambiguous", name
);
2305 print_candidates (decls
.type
);
2309 *newtype
= decls
.type
;
2310 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2311 error ("%qD is already declared in this scope", name
);
2314 /* If *newval is empty, shift any class or enumeration name down. */
2318 *newtype
= NULL_TREE
;
2322 /* Process a using-declaration at function scope. */
2325 do_local_using_decl (tree decl
, tree scope
, tree name
)
2327 tree oldval
, oldtype
, newval
, newtype
;
2328 tree orig_decl
= decl
;
2330 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2331 if (decl
== NULL_TREE
)
2334 if (building_stmt_tree ()
2335 && at_function_scope_p ())
2336 add_decl_expr (decl
);
2338 oldval
= lookup_name_innermost_nonclass_level (name
);
2339 oldtype
= lookup_type_current_level (name
);
2341 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2345 if (is_overloaded_fn (newval
))
2349 /* We only need to push declarations for those functions
2350 that were not already bound in the current level.
2351 The old value might be NULL_TREE, it might be a single
2352 function, or an OVERLOAD. */
2353 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2354 term
= OVL_FUNCTION (oldval
);
2357 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2359 push_overloaded_decl (OVL_CURRENT (fn
),
2360 PUSH_LOCAL
| PUSH_USING
,
2364 push_local_binding (name
, newval
, PUSH_USING
);
2368 push_local_binding (name
, newtype
, PUSH_USING
);
2369 set_identifier_type_value (name
, newtype
);
2372 /* Emit debug info. */
2373 if (!processing_template_decl
)
2374 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2377 /* Returns true if ROOT (a namespace, class, or function) encloses
2378 CHILD. CHILD may be either a class type or a namespace. */
2381 is_ancestor (tree root
, tree child
)
2383 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2384 || TREE_CODE (root
) == FUNCTION_DECL
2385 || CLASS_TYPE_P (root
)));
2386 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2387 || CLASS_TYPE_P (child
)));
2389 /* The global namespace encloses everything. */
2390 if (root
== global_namespace
)
2395 /* If we've run out of scopes, stop. */
2398 /* If we've reached the ROOT, it encloses CHILD. */
2401 /* Go out one level. */
2403 child
= TYPE_NAME (child
);
2404 child
= DECL_CONTEXT (child
);
2408 /* Enter the class or namespace scope indicated by T suitable for name
2409 lookup. T can be arbitrary scope, not necessary nested inside the
2410 current scope. Returns a non-null scope to pop iff pop_scope
2411 should be called later to exit this scope. */
2416 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2417 push_decl_namespace (t
);
2418 else if (CLASS_TYPE_P (t
))
2420 if (!at_class_scope_p ()
2421 || !same_type_p (current_class_type
, t
))
2422 push_nested_class (t
);
2424 /* T is the same as the current scope. There is therefore no
2425 need to re-enter the scope. Since we are not actually
2426 pushing a new scope, our caller should not call
2434 /* Leave scope pushed by push_scope. */
2439 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2440 pop_decl_namespace ();
2441 else if CLASS_TYPE_P (t
)
2442 pop_nested_class ();
2445 /* Subroutine of push_inner_scope. */
2448 push_inner_scope_r (tree outer
, tree inner
)
2453 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2456 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2458 push_inner_scope_r (outer
, prev
);
2459 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2461 struct cp_binding_level
*save_template_parm
= 0;
2462 /* Temporary take out template parameter scopes. They are saved
2463 in reversed order in save_template_parm. */
2464 while (current_binding_level
->kind
== sk_template_parms
)
2466 struct cp_binding_level
*b
= current_binding_level
;
2467 current_binding_level
= b
->level_chain
;
2468 b
->level_chain
= save_template_parm
;
2469 save_template_parm
= b
;
2472 resume_scope (NAMESPACE_LEVEL (inner
));
2473 current_namespace
= inner
;
2475 /* Restore template parameter scopes. */
2476 while (save_template_parm
)
2478 struct cp_binding_level
*b
= save_template_parm
;
2479 save_template_parm
= b
->level_chain
;
2480 b
->level_chain
= current_binding_level
;
2481 current_binding_level
= b
;
2488 /* Enter the scope INNER from current scope. INNER must be a scope
2489 nested inside current scope. This works with both name lookup and
2490 pushing name into scope. In case a template parameter scope is present,
2491 namespace is pushed under the template parameter scope according to
2492 name lookup rule in 14.6.1/6.
2494 Return the former current scope suitable for pop_inner_scope. */
2497 push_inner_scope (tree inner
)
2499 tree outer
= current_scope ();
2501 outer
= current_namespace
;
2503 push_inner_scope_r (outer
, inner
);
2507 /* Exit the current scope INNER back to scope OUTER. */
2510 pop_inner_scope (tree outer
, tree inner
)
2513 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2516 while (outer
!= inner
)
2518 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2520 struct cp_binding_level
*save_template_parm
= 0;
2521 /* Temporary take out template parameter scopes. They are saved
2522 in reversed order in save_template_parm. */
2523 while (current_binding_level
->kind
== sk_template_parms
)
2525 struct cp_binding_level
*b
= current_binding_level
;
2526 current_binding_level
= b
->level_chain
;
2527 b
->level_chain
= save_template_parm
;
2528 save_template_parm
= b
;
2533 /* Restore template parameter scopes. */
2534 while (save_template_parm
)
2536 struct cp_binding_level
*b
= save_template_parm
;
2537 save_template_parm
= b
->level_chain
;
2538 b
->level_chain
= current_binding_level
;
2539 current_binding_level
= b
;
2545 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2549 /* Do a pushlevel for class declarations. */
2552 pushlevel_class (void)
2554 if (ENABLE_SCOPE_CHECKING
)
2557 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2560 /* ...and a poplevel for class declarations. */
2563 poplevel_class (void)
2565 struct cp_binding_level
*level
= class_binding_level
;
2566 cp_class_binding
*cb
;
2570 timevar_push (TV_NAME_LOOKUP
);
2571 gcc_assert (level
!= 0);
2573 /* If we're leaving a toplevel class, cache its binding level. */
2574 if (current_class_depth
== 1)
2575 previous_class_level
= level
;
2576 for (shadowed
= level
->type_shadowed
;
2578 shadowed
= TREE_CHAIN (shadowed
))
2579 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2581 /* Remove the bindings for all of the class-level declarations. */
2582 if (level
->class_shadowed
)
2585 VEC_iterate (cp_class_binding
, level
->class_shadowed
, i
, cb
);
2587 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
.previous
;
2588 ggc_free (level
->class_shadowed
);
2589 level
->class_shadowed
= NULL
;
2592 /* Now, pop out of the binding level which we created up in the
2593 `pushlevel_class' routine. */
2594 if (ENABLE_SCOPE_CHECKING
)
2598 timevar_pop (TV_NAME_LOOKUP
);
2601 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2602 appropriate. DECL is the value to which a name has just been
2603 bound. CLASS_TYPE is the class in which the lookup occurred. */
2606 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2609 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2613 if (TREE_CODE (decl
) == OVERLOAD
)
2614 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2617 gcc_assert (DECL_P (decl
));
2618 context
= context_for_name_lookup (decl
);
2621 if (is_properly_derived_from (class_type
, context
))
2622 INHERITED_VALUE_BINDING_P (binding
) = 1;
2624 INHERITED_VALUE_BINDING_P (binding
) = 0;
2626 else if (binding
->value
== decl
)
2627 /* We only encounter a TREE_LIST when there is an ambiguity in the
2628 base classes. Such an ambiguity can be overridden by a
2629 definition in this class. */
2630 INHERITED_VALUE_BINDING_P (binding
) = 1;
2632 INHERITED_VALUE_BINDING_P (binding
) = 0;
2635 /* Make the declaration of X appear in CLASS scope. */
2638 pushdecl_class_level (tree x
)
2641 bool is_valid
= true;
2643 timevar_push (TV_NAME_LOOKUP
);
2644 /* Get the name of X. */
2645 if (TREE_CODE (x
) == OVERLOAD
)
2646 name
= DECL_NAME (get_first_fn (x
));
2648 name
= DECL_NAME (x
);
2652 is_valid
= push_class_level_binding (name
, x
);
2653 if (TREE_CODE (x
) == TYPE_DECL
)
2654 set_identifier_type_value (name
, x
);
2656 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2658 /* If X is an anonymous aggregate, all of its members are
2659 treated as if they were members of the class containing the
2660 aggregate, for naming purposes. */
2663 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= TREE_CHAIN (f
))
2665 location_t save_location
= input_location
;
2666 input_location
= DECL_SOURCE_LOCATION (f
);
2667 if (!pushdecl_class_level (f
))
2669 input_location
= save_location
;
2672 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, is_valid
);
2675 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2676 scope. If the value returned is non-NULL, and the PREVIOUS field
2677 is not set, callers must set the PREVIOUS field explicitly. */
2679 static cxx_binding
*
2680 get_class_binding (tree name
, cxx_scope
*scope
)
2685 cxx_binding
*binding
;
2687 class_type
= scope
->this_entity
;
2689 /* Get the type binding. */
2690 type_binding
= lookup_member (class_type
, name
,
2691 /*protect=*/2, /*want_type=*/true);
2692 /* Get the value binding. */
2693 value_binding
= lookup_member (class_type
, name
,
2694 /*protect=*/2, /*want_type=*/false);
2697 && (TREE_CODE (value_binding
) == TYPE_DECL
2698 || DECL_CLASS_TEMPLATE_P (value_binding
)
2699 || (TREE_CODE (value_binding
) == TREE_LIST
2700 && TREE_TYPE (value_binding
) == error_mark_node
2701 && (TREE_CODE (TREE_VALUE (value_binding
))
2703 /* We found a type binding, even when looking for a non-type
2704 binding. This means that we already processed this binding
2707 else if (value_binding
)
2709 if (TREE_CODE (value_binding
) == TREE_LIST
2710 && TREE_TYPE (value_binding
) == error_mark_node
)
2711 /* NAME is ambiguous. */
2713 else if (BASELINK_P (value_binding
))
2714 /* NAME is some overloaded functions. */
2715 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2718 /* If we found either a type binding or a value binding, create a
2719 new binding object. */
2720 if (type_binding
|| value_binding
)
2722 binding
= new_class_binding (name
,
2726 /* This is a class-scope binding, not a block-scope binding. */
2727 LOCAL_BINDING_P (binding
) = 0;
2728 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2736 /* Make the declaration(s) of X appear in CLASS scope under the name
2737 NAME. Returns true if the binding is valid. */
2740 push_class_level_binding (tree name
, tree x
)
2742 cxx_binding
*binding
;
2746 timevar_push (TV_NAME_LOOKUP
);
2747 /* The class_binding_level will be NULL if x is a template
2748 parameter name in a member template. */
2749 if (!class_binding_level
)
2750 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2752 if (name
== error_mark_node
)
2753 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2755 /* Check for invalid member names. */
2756 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2757 /* We could have been passed a tree list if this is an ambiguous
2758 declaration. If so, pull the declaration out because
2759 check_template_shadow will not handle a TREE_LIST. */
2760 if (TREE_CODE (decl
) == TREE_LIST
2761 && TREE_TYPE (decl
) == error_mark_node
)
2762 decl
= TREE_VALUE (decl
);
2764 if (!check_template_shadow (decl
))
2765 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2769 If T is the name of a class, then each of the following shall
2770 have a name different from T:
2772 -- every static data member of class T;
2774 -- every member of class T that is itself a type;
2776 -- every enumerator of every member of class T that is an
2779 -- every member of every anonymous union that is a member of
2782 (Non-static data members were also forbidden to have the same
2783 name as T until TC1.) */
2784 if ((TREE_CODE (x
) == VAR_DECL
2785 || TREE_CODE (x
) == CONST_DECL
2786 || (TREE_CODE (x
) == TYPE_DECL
2787 && !DECL_SELF_REFERENCE_P (x
))
2788 /* A data member of an anonymous union. */
2789 || (TREE_CODE (x
) == FIELD_DECL
2790 && DECL_CONTEXT (x
) != current_class_type
))
2791 && DECL_NAME (x
) == constructor_name (current_class_type
))
2793 tree scope
= context_for_name_lookup (x
);
2794 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
2796 error ("%qD has the same name as the class in which it is "
2799 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2803 /* Get the current binding for NAME in this class, if any. */
2804 binding
= IDENTIFIER_BINDING (name
);
2805 if (!binding
|| binding
->scope
!= class_binding_level
)
2807 binding
= get_class_binding (name
, class_binding_level
);
2808 /* If a new binding was created, put it at the front of the
2809 IDENTIFIER_BINDING list. */
2812 binding
->previous
= IDENTIFIER_BINDING (name
);
2813 IDENTIFIER_BINDING (name
) = binding
;
2817 /* If there is already a binding, then we may need to update the
2819 if (binding
&& binding
->value
)
2821 tree bval
= binding
->value
;
2822 tree old_decl
= NULL_TREE
;
2824 if (INHERITED_VALUE_BINDING_P (binding
))
2826 /* If the old binding was from a base class, and was for a
2827 tag name, slide it over to make room for the new binding.
2828 The old binding is still visible if explicitly qualified
2829 with a class-key. */
2830 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2831 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2833 old_decl
= binding
->type
;
2834 binding
->type
= bval
;
2835 binding
->value
= NULL_TREE
;
2836 INHERITED_VALUE_BINDING_P (binding
) = 0;
2841 /* Any inherited type declaration is hidden by the type
2842 declaration in the derived class. */
2843 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
))
2844 binding
->type
= NULL_TREE
;
2847 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2849 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2850 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2851 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
2853 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
2854 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2856 if (old_decl
&& binding
->scope
== class_binding_level
)
2859 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2860 here. This function is only used to register bindings
2861 from with the class definition itself. */
2862 INHERITED_VALUE_BINDING_P (binding
) = 0;
2863 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2867 /* Note that we declared this value so that we can issue an error if
2868 this is an invalid redeclaration of a name already used for some
2870 note_name_declared_in_class (name
, decl
);
2872 /* If we didn't replace an existing binding, put the binding on the
2873 stack of bindings for the identifier, and update the shadowed
2875 if (binding
&& binding
->scope
== class_binding_level
)
2876 /* Supplement the existing binding. */
2877 ok
= supplement_binding (binding
, decl
);
2880 /* Create a new binding. */
2881 push_binding (name
, decl
, class_binding_level
);
2885 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
2888 /* Process "using SCOPE::NAME" in a class scope. Return the
2889 USING_DECL created. */
2892 do_class_using_decl (tree scope
, tree name
)
2894 /* The USING_DECL returned by this function. */
2896 /* The declaration (or declarations) name by this using
2897 declaration. NULL if we are in a template and cannot figure out
2898 what has been named. */
2900 /* True if SCOPE is a dependent type. */
2901 bool scope_dependent_p
;
2902 /* True if SCOPE::NAME is dependent. */
2903 bool name_dependent_p
;
2904 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2905 bool bases_dependent_p
;
2910 if (name
== error_mark_node
)
2913 if (!scope
|| !TYPE_P (scope
))
2915 error ("using-declaration for non-member at class scope");
2919 /* Make sure the name is not invalid */
2920 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2922 error ("%<%T::%D%> names destructor", scope
, name
);
2925 if (MAYBE_CLASS_TYPE_P (scope
) && constructor_name_p (name
, scope
))
2927 error ("%<%T::%D%> names constructor", scope
, name
);
2930 if (constructor_name_p (name
, current_class_type
))
2932 error ("%<%T::%D%> names constructor in %qT",
2933 scope
, name
, current_class_type
);
2937 scope_dependent_p
= dependent_type_p (scope
);
2938 name_dependent_p
= (scope_dependent_p
2939 || (IDENTIFIER_TYPENAME_P (name
)
2940 && dependent_type_p (TREE_TYPE (name
))));
2942 bases_dependent_p
= false;
2943 if (processing_template_decl
)
2944 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
2945 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
2947 if (dependent_type_p (TREE_TYPE (base_binfo
)))
2949 bases_dependent_p
= true;
2955 /* From [namespace.udecl]:
2957 A using-declaration used as a member-declaration shall refer to a
2958 member of a base class of the class being defined.
2960 In general, we cannot check this constraint in a template because
2961 we do not know the entire set of base classes of the current
2962 class type. However, if all of the base classes are
2963 non-dependent, then we can avoid delaying the check until
2965 if (!scope_dependent_p
)
2968 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
2969 if (b_kind
< bk_proper_base
)
2971 if (!bases_dependent_p
)
2973 error_not_base_type (scope
, current_class_type
);
2977 else if (!name_dependent_p
)
2979 decl
= lookup_member (binfo
, name
, 0, false);
2982 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
2986 /* The binfo from which the functions came does not matter. */
2987 if (BASELINK_P (decl
))
2988 decl
= BASELINK_FUNCTIONS (decl
);
2992 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2993 USING_DECL_DECLS (value
) = decl
;
2994 USING_DECL_SCOPE (value
) = scope
;
2995 DECL_DEPENDENT_P (value
) = !decl
;
3001 /* Return the binding value for name in scope. */
3004 namespace_binding (tree name
, tree scope
)
3006 cxx_binding
*binding
;
3009 scope
= global_namespace
;
3011 /* Unnecessary for the global namespace because it can't be an alias. */
3012 scope
= ORIGINAL_NAMESPACE (scope
);
3014 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3016 return binding
? binding
->value
: NULL_TREE
;
3019 /* Set the binding value for name in scope. */
3022 set_namespace_binding (tree name
, tree scope
, tree val
)
3026 timevar_push (TV_NAME_LOOKUP
);
3027 if (scope
== NULL_TREE
)
3028 scope
= global_namespace
;
3029 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3030 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3033 supplement_binding (b
, val
);
3034 timevar_pop (TV_NAME_LOOKUP
);
3037 /* Set the context of a declaration to scope. Complain if we are not
3041 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3045 /* Get rid of namespace aliases. */
3046 scope
= ORIGINAL_NAMESPACE (scope
);
3048 /* It is ok for friends to be qualified in parallel space. */
3049 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3050 error ("declaration of %qD not in a namespace surrounding %qD",
3052 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3054 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3055 if (scope
== current_namespace
)
3057 if (at_namespace_scope_p ())
3058 error ("explicit qualification in declaration of %qD",
3063 /* See whether this has been declared in the namespace. */
3064 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3065 if (old
== error_mark_node
)
3066 /* No old declaration at all. */
3068 if (!is_overloaded_fn (decl
))
3069 /* Don't compare non-function decls with decls_match here, since
3070 it can't check for the correct constness at this
3071 point. pushdecl will find those errors later. */
3073 /* Since decl is a function, old should contain a function decl. */
3074 if (!is_overloaded_fn (old
))
3076 fn
= OVL_CURRENT (old
);
3077 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (fn
)))
3079 /* A template can be explicitly specialized in any namespace. */
3080 if (processing_explicit_instantiation
)
3082 if (processing_template_decl
|| processing_specialization
)
3083 /* We have not yet called push_template_decl to turn a
3084 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3085 match. But, we'll check later, when we construct the
3088 /* Instantiations or specializations of templates may be declared as
3089 friends in any namespace. */
3090 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3092 if (is_overloaded_fn (old
))
3094 for (; old
; old
= OVL_NEXT (old
))
3095 if (decls_match (decl
, OVL_CURRENT (old
)))
3098 else if (decls_match (decl
, old
))
3101 error ("%qD should have been declared inside %qD", decl
, scope
);
3104 /* Return the namespace where the current declaration is declared. */
3107 current_decl_namespace (void)
3110 /* If we have been pushed into a different namespace, use it. */
3111 if (decl_namespace_list
)
3112 return TREE_PURPOSE (decl_namespace_list
);
3114 if (current_class_type
)
3115 result
= decl_namespace_context (current_class_type
);
3116 else if (current_function_decl
)
3117 result
= decl_namespace_context (current_function_decl
);
3119 result
= current_namespace
;
3123 /* Process any ATTRIBUTES on a namespace definition. Currently only
3124 attribute visibility is meaningful, which is a property of the syntactic
3125 block rather than the namespace as a whole, so we don't touch the
3126 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3129 handle_namespace_attrs (tree ns
, tree attributes
)
3132 bool saw_vis
= false;
3134 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3136 tree name
= TREE_PURPOSE (d
);
3137 tree args
= TREE_VALUE (d
);
3139 #ifdef HANDLE_PRAGMA_VISIBILITY
3140 if (is_attribute_p ("visibility", name
))
3142 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3143 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3145 warning (OPT_Wattributes
,
3146 "%qD attribute requires a single NTBS argument",
3151 if (!TREE_PUBLIC (ns
))
3152 warning (OPT_Wattributes
,
3153 "%qD attribute is meaningless since members of the "
3154 "anonymous namespace get local symbols", name
);
3156 push_visibility (TREE_STRING_POINTER (x
));
3162 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3171 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3172 select a name that is unique to this compilation unit. */
3175 push_namespace (tree name
)
3179 int implicit_use
= 0;
3182 timevar_push (TV_NAME_LOOKUP
);
3184 /* We should not get here if the global_namespace is not yet constructed
3185 nor if NAME designates the global namespace: The global scope is
3186 constructed elsewhere. */
3187 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3191 name
= get_anonymous_namespace_name();
3192 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3194 /* Reopening anonymous namespace. */
3200 /* Check whether this is an extended namespace definition. */
3201 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3202 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3205 if (DECL_NAMESPACE_ALIAS (d
))
3207 error ("namespace alias %qD not allowed here, assuming %qD",
3208 d
, DECL_NAMESPACE_ALIAS (d
));
3209 d
= DECL_NAMESPACE_ALIAS (d
);
3216 /* Make a new namespace, binding the name to it. */
3217 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3218 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3219 /* The name of this namespace is not visible to other translation
3220 units if it is an anonymous namespace or member thereof. */
3221 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3222 TREE_PUBLIC (d
) = 0;
3224 TREE_PUBLIC (d
) = 1;
3228 /* Clear DECL_NAME for the benefit of debugging back ends. */
3229 SET_DECL_ASSEMBLER_NAME (d
, name
);
3230 DECL_NAME (d
) = NULL_TREE
;
3232 begin_scope (sk_namespace
, d
);
3235 resume_scope (NAMESPACE_LEVEL (d
));
3238 do_using_directive (d
);
3239 /* Enter the name space. */
3240 current_namespace
= d
;
3242 timevar_pop (TV_NAME_LOOKUP
);
3245 /* Pop from the scope of the current namespace. */
3248 pop_namespace (void)
3250 gcc_assert (current_namespace
!= global_namespace
);
3251 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3252 /* The binding level is not popped, as it might be re-opened later. */
3256 /* Push into the scope of the namespace NS, even if it is deeply
3257 nested within another namespace. */
3260 push_nested_namespace (tree ns
)
3262 if (ns
== global_namespace
)
3263 push_to_top_level ();
3266 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3267 push_namespace (DECL_NAME (ns
));
3271 /* Pop back from the scope of the namespace NS, which was previously
3272 entered with push_nested_namespace. */
3275 pop_nested_namespace (tree ns
)
3277 timevar_push (TV_NAME_LOOKUP
);
3278 while (ns
!= global_namespace
)
3281 ns
= CP_DECL_CONTEXT (ns
);
3284 pop_from_top_level ();
3285 timevar_pop (TV_NAME_LOOKUP
);
3288 /* Temporarily set the namespace for the current declaration. */
3291 push_decl_namespace (tree decl
)
3293 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3294 decl
= decl_namespace_context (decl
);
3295 decl_namespace_list
= tree_cons (ORIGINAL_NAMESPACE (decl
),
3296 NULL_TREE
, decl_namespace_list
);
3299 /* [namespace.memdef]/2 */
3302 pop_decl_namespace (void)
3304 decl_namespace_list
= TREE_CHAIN (decl_namespace_list
);
3307 /* Return the namespace that is the common ancestor
3308 of two given namespaces. */
3311 namespace_ancestor (tree ns1
, tree ns2
)
3313 timevar_push (TV_NAME_LOOKUP
);
3314 if (is_ancestor (ns1
, ns2
))
3315 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ns1
);
3316 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
3317 namespace_ancestor (CP_DECL_CONTEXT (ns1
), ns2
));
3320 /* Process a namespace-alias declaration. */
3323 do_namespace_alias (tree alias
, tree name_space
)
3325 if (name_space
== error_mark_node
)
3328 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3330 name_space
= ORIGINAL_NAMESPACE (name_space
);
3332 /* Build the alias. */
3333 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3334 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3335 DECL_EXTERNAL (alias
) = 1;
3336 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3339 /* Emit debug info for namespace alias. */
3340 (*debug_hooks
->global_decl
) (alias
);
3343 /* Like pushdecl, only it places X in the current namespace,
3347 pushdecl_namespace_level (tree x
, bool is_friend
)
3349 struct cp_binding_level
*b
= current_binding_level
;
3352 timevar_push (TV_NAME_LOOKUP
);
3353 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3355 /* Now, the type_shadowed stack may screw us. Munge it so it does
3357 if (TREE_CODE (t
) == TYPE_DECL
)
3359 tree name
= DECL_NAME (t
);
3361 tree
*ptr
= (tree
*)0;
3362 for (; !global_scope_p (b
); b
= b
->level_chain
)
3364 tree shadowed
= b
->type_shadowed
;
3365 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3366 if (TREE_PURPOSE (shadowed
) == name
)
3368 ptr
= &TREE_VALUE (shadowed
);
3369 /* Can't break out of the loop here because sometimes
3370 a binding level will have duplicate bindings for
3371 PT names. It's gross, but I haven't time to fix it. */
3374 newval
= TREE_TYPE (t
);
3375 if (ptr
== (tree
*)0)
3377 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3378 up here if this is changed to an assertion. --KR */
3379 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3386 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3389 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3390 directive is not directly from the source. Also find the common
3391 ancestor and let our users know about the new namespace */
3393 add_using_namespace (tree user
, tree used
, bool indirect
)
3396 timevar_push (TV_NAME_LOOKUP
);
3397 /* Using oneself is a no-op. */
3400 timevar_pop (TV_NAME_LOOKUP
);
3403 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3404 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3405 /* Check if we already have this. */
3406 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3410 /* Promote to direct usage. */
3411 TREE_INDIRECT_USING (t
) = 0;
3412 timevar_pop (TV_NAME_LOOKUP
);
3416 /* Add used to the user's using list. */
3417 DECL_NAMESPACE_USING (user
)
3418 = tree_cons (used
, namespace_ancestor (user
, used
),
3419 DECL_NAMESPACE_USING (user
));
3421 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3423 /* Add user to the used's users list. */
3424 DECL_NAMESPACE_USERS (used
)
3425 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3427 /* Recursively add all namespaces used. */
3428 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3429 /* indirect usage */
3430 add_using_namespace (user
, TREE_PURPOSE (t
), 1);
3432 /* Tell everyone using us about the new used namespaces. */
3433 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3434 add_using_namespace (TREE_PURPOSE (t
), used
, 1);
3435 timevar_pop (TV_NAME_LOOKUP
);
3438 /* Process a using-declaration not appearing in class or local scope. */
3441 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3443 tree oldval
, oldtype
, newval
, newtype
;
3444 tree orig_decl
= decl
;
3445 cxx_binding
*binding
;
3447 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3448 if (decl
== NULL_TREE
)
3451 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3453 oldval
= binding
->value
;
3454 oldtype
= binding
->type
;
3456 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3458 /* Emit debug info. */
3459 if (!processing_template_decl
)
3460 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3462 /* Copy declarations found. */
3464 binding
->value
= newval
;
3466 binding
->type
= newtype
;
3469 /* Process a using-directive. */
3472 do_using_directive (tree name_space
)
3474 tree context
= NULL_TREE
;
3476 if (name_space
== error_mark_node
)
3479 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3481 if (building_stmt_tree ())
3482 add_stmt (build_stmt (USING_STMT
, name_space
));
3483 name_space
= ORIGINAL_NAMESPACE (name_space
);
3485 if (!toplevel_bindings_p ())
3487 push_using_directive (name_space
);
3492 add_using_namespace (current_namespace
, name_space
, 0);
3493 if (current_namespace
!= global_namespace
)
3494 context
= current_namespace
;
3496 /* Emit debugging info. */
3497 if (!processing_template_decl
)
3498 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
3503 /* Deal with a using-directive seen by the parser. Currently we only
3504 handle attributes here, since they cannot appear inside a template. */
3507 parse_using_directive (tree name_space
, tree attribs
)
3511 do_using_directive (name_space
);
3513 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3515 tree name
= TREE_PURPOSE (a
);
3516 if (is_attribute_p ("strong", name
))
3518 if (!toplevel_bindings_p ())
3519 error ("strong using only meaningful at namespace scope");
3520 else if (name_space
!= error_mark_node
)
3522 if (!is_ancestor (current_namespace
, name_space
))
3523 error ("current namespace %qD does not enclose strongly used namespace %qD",
3524 current_namespace
, name_space
);
3525 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
3526 = tree_cons (current_namespace
, 0,
3527 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
3531 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3535 /* Like pushdecl, only it places X in the global scope if appropriate.
3536 Calls cp_finish_decl to register the variable, initializing it with
3537 *INIT, if INIT is non-NULL. */
3540 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3542 timevar_push (TV_NAME_LOOKUP
);
3543 push_to_top_level ();
3544 x
= pushdecl_namespace_level (x
, is_friend
);
3546 finish_decl (x
, *init
, NULL_TREE
);
3547 pop_from_top_level ();
3548 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
3551 /* Like pushdecl, only it places X in the global scope if appropriate. */
3554 pushdecl_top_level (tree x
)
3556 return pushdecl_top_level_1 (x
, NULL
, false);
3559 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3562 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3564 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3567 /* Like pushdecl, only it places X in the global scope if
3568 appropriate. Calls cp_finish_decl to register the variable,
3569 initializing it with INIT. */
3572 pushdecl_top_level_and_finish (tree x
, tree init
)
3574 return pushdecl_top_level_1 (x
, &init
, false);
3577 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3578 duplicates. The first list becomes the tail of the result.
3580 The algorithm is O(n^2). We could get this down to O(n log n) by
3581 doing a sort on the addresses of the functions, if that becomes
3585 merge_functions (tree s1
, tree s2
)
3587 for (; s2
; s2
= OVL_NEXT (s2
))
3589 tree fn2
= OVL_CURRENT (s2
);
3592 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3594 tree fn1
= OVL_CURRENT (fns1
);
3596 /* If the function from S2 is already in S1, there is no
3597 need to add it again. For `extern "C"' functions, we
3598 might have two FUNCTION_DECLs for the same function, in
3599 different namespaces; again, we only need one of them. */
3601 || (DECL_EXTERN_C_P (fn1
) && DECL_EXTERN_C_P (fn2
)
3602 && DECL_NAME (fn1
) == DECL_NAME (fn2
)))
3606 /* If we exhausted all of the functions in S1, FN2 is new. */
3608 s1
= build_overload (fn2
, s1
);
3613 /* This should return an error not all definitions define functions.
3614 It is not an error if we find two functions with exactly the
3615 same signature, only if these are selected in overload resolution.
3616 old is the current set of bindings, new_binding the freshly-found binding.
3617 XXX Do we want to give *all* candidates in case of ambiguity?
3618 XXX In what way should I treat extern declarations?
3619 XXX I don't want to repeat the entire duplicate_decls here */
3622 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
3625 gcc_assert (old
!= NULL
);
3627 /* Copy the type. */
3628 type
= new_binding
->type
;
3629 if (LOOKUP_NAMESPACES_ONLY (flags
)
3630 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
3633 /* Copy the value. */
3634 val
= new_binding
->value
;
3637 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
3640 switch (TREE_CODE (val
))
3643 /* If we expect types or namespaces, and not templates,
3644 or this is not a template class. */
3645 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3646 && !DECL_CLASS_TEMPLATE_P (val
)))
3650 if (LOOKUP_NAMESPACES_ONLY (flags
)
3651 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
3654 case NAMESPACE_DECL
:
3655 if (LOOKUP_TYPES_ONLY (flags
))
3659 /* Ignore built-in functions that are still anticipated. */
3660 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3664 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3669 /* If val is hidden, shift down any class or enumeration name. */
3678 else if (val
&& val
!= old
->value
)
3680 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3681 old
->value
= merge_functions (old
->value
, val
);
3684 old
->value
= tree_cons (NULL_TREE
, old
->value
,
3685 build_tree_list (NULL_TREE
, val
));
3686 TREE_TYPE (old
->value
) = error_mark_node
;
3692 else if (type
&& old
->type
!= type
)
3694 old
->type
= tree_cons (NULL_TREE
, old
->type
,
3695 build_tree_list (NULL_TREE
, type
));
3696 TREE_TYPE (old
->type
) = error_mark_node
;
3700 /* Return the declarations that are members of the namespace NS. */
3703 cp_namespace_decls (tree ns
)
3705 return NAMESPACE_LEVEL (ns
)->names
;
3708 /* Combine prefer_type and namespaces_only into flags. */
3711 lookup_flags (int prefer_type
, int namespaces_only
)
3713 if (namespaces_only
)
3714 return LOOKUP_PREFER_NAMESPACES
;
3715 if (prefer_type
> 1)
3716 return LOOKUP_PREFER_TYPES
;
3717 if (prefer_type
> 0)
3718 return LOOKUP_PREFER_BOTH
;
3722 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3723 ignore it or not. Subroutine of lookup_name_real and
3724 lookup_type_scope. */
3727 qualify_lookup (tree val
, int flags
)
3729 if (val
== NULL_TREE
)
3731 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3733 if ((flags
& LOOKUP_PREFER_TYPES
)
3734 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3736 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
3741 /* Given a lookup that returned VAL, decide if we want to ignore it or
3742 not based on DECL_ANTICIPATED. */
3745 hidden_name_p (tree val
)
3748 && DECL_LANG_SPECIFIC (val
)
3749 && DECL_ANTICIPATED (val
))
3754 /* Remove any hidden friend functions from a possibly overloaded set
3758 remove_hidden_names (tree fns
)
3763 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
3765 else if (TREE_CODE (fns
) == OVERLOAD
)
3769 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3770 if (hidden_name_p (OVL_CURRENT (o
)))
3776 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3777 if (!hidden_name_p (OVL_CURRENT (o
)))
3778 n
= build_overload (OVL_CURRENT (o
), n
);
3786 /* Unscoped lookup of a global: iterate over current namespaces,
3787 considering using-directives. */
3790 unqualified_namespace_lookup (tree name
, int flags
)
3792 tree initial
= current_decl_namespace ();
3793 tree scope
= initial
;
3795 struct cp_binding_level
*level
;
3796 tree val
= NULL_TREE
;
3798 timevar_push (TV_NAME_LOOKUP
);
3800 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
3802 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3804 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3807 ambiguous_decl (&binding
, b
, flags
);
3809 /* Add all _DECLs seen through local using-directives. */
3810 for (level
= current_binding_level
;
3811 level
->kind
!= sk_namespace
;
3812 level
= level
->level_chain
)
3813 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
3815 /* Give up because of error. */
3816 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3818 /* Add all _DECLs seen through global using-directives. */
3819 /* XXX local and global using lists should work equally. */
3823 if (!lookup_using_namespace (name
, &binding
,
3824 DECL_NAMESPACE_USING (siter
),
3826 /* Give up because of error. */
3827 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3828 if (siter
== scope
) break;
3829 siter
= CP_DECL_CONTEXT (siter
);
3832 val
= binding
.value
;
3833 if (scope
== global_namespace
)
3836 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3839 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3840 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3843 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3844 declaration found. If no suitable declaration can be found,
3845 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3846 neither a class-type nor a namespace a diagnostic is issued. */
3849 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
3854 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3856 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3858 flags
|= LOOKUP_COMPLAIN
;
3860 flags
|= LOOKUP_PREFER_TYPES
;
3861 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
3864 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
3865 t
= lookup_enumerator (scope
, name
);
3866 else if (is_class_type (scope
, complain
))
3867 t
= lookup_member (scope
, name
, 2, is_type_p
);
3870 return error_mark_node
;
3874 /* Subroutine of unqualified_namespace_lookup:
3875 Add the bindings of NAME in used namespaces to VAL.
3876 We are currently looking for names in namespace SCOPE, so we
3877 look through USINGS for using-directives of namespaces
3878 which have SCOPE as a common ancestor with the current scope.
3879 Returns false on errors. */
3882 lookup_using_namespace (tree name
, struct scope_binding
*val
,
3883 tree usings
, tree scope
, int flags
)
3886 timevar_push (TV_NAME_LOOKUP
);
3887 /* Iterate over all used namespaces in current, searching for using
3888 directives of scope. */
3889 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
3890 if (TREE_VALUE (iter
) == scope
)
3892 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
3894 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
3895 /* Resolve ambiguities. */
3897 ambiguous_decl (val
, val1
, flags
);
3899 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
->value
!= error_mark_node
);
3903 Accepts the NAME to lookup and its qualifying SCOPE.
3904 Returns the name/type pair found into the cxx_binding *RESULT,
3905 or false on error. */
3908 qualified_lookup_using_namespace (tree name
, tree scope
,
3909 struct scope_binding
*result
, int flags
)
3911 /* Maintain a list of namespaces visited... */
3912 tree seen
= NULL_TREE
;
3913 /* ... and a list of namespace yet to see. */
3914 tree todo
= NULL_TREE
;
3915 tree todo_maybe
= NULL_TREE
;
3917 timevar_push (TV_NAME_LOOKUP
);
3918 /* Look through namespace aliases. */
3919 scope
= ORIGINAL_NAMESPACE (scope
);
3920 while (scope
&& result
->value
!= error_mark_node
)
3922 cxx_binding
*binding
=
3923 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3924 seen
= tree_cons (scope
, NULL_TREE
, seen
);
3926 ambiguous_decl (result
, binding
, flags
);
3928 /* Consider strong using directives always, and non-strong ones
3929 if we haven't found a binding yet. ??? Shouldn't we consider
3930 non-strong ones if the initial RESULT is non-NULL, but the
3931 binding in the given namespace is? */
3932 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
3933 usings
= TREE_CHAIN (usings
))
3934 /* If this was a real directive, and we have not seen it. */
3935 if (!TREE_INDIRECT_USING (usings
))
3937 /* Try to avoid queuing the same namespace more than once,
3938 the exception being when a namespace was already
3939 enqueued for todo_maybe and then a strong using is
3940 found for it. We could try to remove it from
3941 todo_maybe, but it's probably not worth the effort. */
3942 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
))
3943 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3944 && !purpose_member (TREE_PURPOSE (usings
), todo
))
3945 todo
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
, todo
);
3946 else if ((!result
->value
&& !result
->type
)
3947 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3948 && !purpose_member (TREE_PURPOSE (usings
), todo
)
3949 && !purpose_member (TREE_PURPOSE (usings
), todo_maybe
))
3950 todo_maybe
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
,
3955 scope
= TREE_PURPOSE (todo
);
3956 todo
= TREE_CHAIN (todo
);
3959 && (!result
->value
&& !result
->type
))
3961 scope
= TREE_PURPOSE (todo_maybe
);
3962 todo
= TREE_CHAIN (todo_maybe
);
3963 todo_maybe
= NULL_TREE
;
3966 scope
= NULL_TREE
; /* If there never was a todo list. */
3968 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
->value
!= error_mark_node
);
3971 /* Return the innermost non-namespace binding for NAME from a scope
3972 containing BINDING, or, if BINDING is NULL, the current scope. If
3973 CLASS_P is false, then class bindings are ignored. */
3976 outer_binding (tree name
,
3977 cxx_binding
*binding
,
3982 cxx_scope
*outer_scope
;
3986 scope
= binding
->scope
->level_chain
;
3987 outer
= binding
->previous
;
3991 scope
= current_binding_level
;
3992 outer
= IDENTIFIER_BINDING (name
);
3994 outer_scope
= outer
? outer
->scope
: NULL
;
3996 /* Because we create class bindings lazily, we might be missing a
3997 class binding for NAME. If there are any class binding levels
3998 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3999 declared, we must lookup NAME in those class scopes. */
4001 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4003 if (scope
->kind
== sk_class
)
4005 cxx_binding
*class_binding
;
4007 class_binding
= get_class_binding (name
, scope
);
4010 /* Thread this new class-scope binding onto the
4011 IDENTIFIER_BINDING list so that future lookups
4013 class_binding
->previous
= outer
;
4015 binding
->previous
= class_binding
;
4017 IDENTIFIER_BINDING (name
) = class_binding
;
4018 return class_binding
;
4021 scope
= scope
->level_chain
;
4027 /* Return the innermost block-scope or class-scope value binding for
4028 NAME, or NULL_TREE if there is no such binding. */
4031 innermost_non_namespace_value (tree name
)
4033 cxx_binding
*binding
;
4034 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4035 return binding
? binding
->value
: NULL_TREE
;
4038 /* Look up NAME in the current binding level and its superiors in the
4039 namespace of variables, functions and typedefs. Return a ..._DECL
4040 node of some kind representing its definition if there is only one
4041 such declaration, or return a TREE_LIST with all the overloaded
4042 definitions if there are many, or return 0 if it is undefined.
4043 Hidden name, either friend declaration or built-in function, are
4046 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4047 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4048 Otherwise we prefer non-TYPE_DECLs.
4050 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4051 BLOCK_P is false, bindings in block scopes are ignored. */
4054 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4055 int namespaces_only
, int flags
)
4058 tree val
= NULL_TREE
;
4060 timevar_push (TV_NAME_LOOKUP
);
4061 /* Conversion operators are handled specially because ordinary
4062 unqualified name lookup will not find template conversion
4064 if (IDENTIFIER_TYPENAME_P (name
))
4066 struct cp_binding_level
*level
;
4068 for (level
= current_binding_level
;
4069 level
&& level
->kind
!= sk_namespace
;
4070 level
= level
->level_chain
)
4075 /* A conversion operator can only be declared in a class
4077 if (level
->kind
!= sk_class
)
4080 /* Lookup the conversion operator in the class. */
4081 class_type
= level
->this_entity
;
4082 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4084 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, operators
);
4087 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4090 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4092 /* First, look in non-namespace scopes. */
4094 if (current_class_type
== NULL_TREE
)
4097 if (block_p
|| !nonclass
)
4098 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4100 iter
= outer_binding (name
, iter
, !nonclass
))
4104 /* Skip entities we don't want. */
4105 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4108 /* If this is the kind of thing we're looking for, we're done. */
4109 if (qualify_lookup (iter
->value
, flags
))
4110 binding
= iter
->value
;
4111 else if ((flags
& LOOKUP_PREFER_TYPES
)
4112 && qualify_lookup (iter
->type
, flags
))
4113 binding
= iter
->type
;
4115 binding
= NULL_TREE
;
4119 if (hidden_name_p (binding
))
4121 /* A non namespace-scope binding can only be hidden if
4122 we are in a local class, due to friend declarations.
4123 In particular, consider:
4128 void g() { B* b; } // error: B is hidden
4133 The standard says that "B" is a local class in "f"
4134 (but not nested within "A") -- but that name lookup
4135 for "B" does not find this declaration until it is
4136 declared directly with "f".
4142 If a friend declaration appears in a local class and
4143 the name specified is an unqualified name, a prior
4144 declaration is looked up without considering scopes
4145 that are outside the innermost enclosing non-class
4146 scope. For a friend class declaration, if there is no
4147 prior declaration, the class that is specified
4148 belongs to the innermost enclosing non-class scope,
4149 but if it is subsequently referenced, its name is not
4150 found by name lookup until a matching declaration is
4151 provided in the innermost enclosing nonclass scope.
4153 gcc_assert (current_class_type
&&
4154 LOCAL_CLASS_P (current_class_type
));
4156 /* This binding comes from a friend declaration in the local
4157 class. The standard (11.4.8) states that the lookup can
4158 only succeed if there is a non-hidden declaration in the
4159 current scope, which is not the case here. */
4160 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4167 /* Now lookup in namespace scopes. */
4169 val
= unqualified_namespace_lookup (name
, flags
);
4171 /* If we have a single function from a using decl, pull it out. */
4172 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4173 val
= OVL_FUNCTION (val
);
4175 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4179 lookup_name_nonclass (tree name
)
4181 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4185 lookup_function_nonclass (tree name
, tree args
, bool block_p
)
4188 lookup_arg_dependent (name
,
4189 lookup_name_real (name
, 0, 1, block_p
, 0,
4195 lookup_name (tree name
)
4197 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4201 lookup_name_prefer_type (tree name
, int prefer_type
)
4203 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
4204 0, LOOKUP_COMPLAIN
);
4207 /* Look up NAME for type used in elaborated name specifier in
4208 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4209 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4210 name, more scopes are checked if cleanup or template parameter
4211 scope is encountered.
4213 Unlike lookup_name_real, we make sure that NAME is actually
4214 declared in the desired scope, not from inheritance, nor using
4215 directive. For using declaration, there is DR138 still waiting
4216 to be resolved. Hidden name coming from an earlier friend
4217 declaration is also returned.
4219 A TYPE_DECL best matching the NAME is returned. Catching error
4220 and issuing diagnostics are caller's responsibility. */
4223 lookup_type_scope (tree name
, tag_scope scope
)
4225 cxx_binding
*iter
= NULL
;
4226 tree val
= NULL_TREE
;
4228 timevar_push (TV_NAME_LOOKUP
);
4230 /* Look in non-namespace scope first. */
4231 if (current_binding_level
->kind
!= sk_namespace
)
4232 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4233 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4235 /* Check if this is the kind of thing we're looking for.
4236 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4237 base class. For ITER->VALUE, we can simply use
4238 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4241 We check ITER->TYPE before ITER->VALUE in order to handle
4242 typedef struct C {} C;
4245 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4246 && (scope
!= ts_current
4247 || LOCAL_BINDING_P (iter
)
4248 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4250 else if ((scope
!= ts_current
4251 || !INHERITED_VALUE_BINDING_P (iter
))
4252 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4259 /* Look in namespace scope. */
4262 iter
= cxx_scope_find_binding_for_name
4263 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4267 /* If this is the kind of thing we're looking for, we're done. */
4268 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4270 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4276 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4277 and template parameter scopes. */
4280 struct cp_binding_level
*b
= current_binding_level
;
4283 if (iter
->scope
== b
)
4284 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4286 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
4287 || b
->kind
== sk_function_parms
)
4289 else if (b
->kind
== sk_class
4290 && scope
== ts_within_enclosing_non_class
)
4297 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4300 /* Similar to `lookup_name' but look only in the innermost non-class
4304 lookup_name_innermost_nonclass_level (tree name
)
4306 struct cp_binding_level
*b
;
4309 timevar_push (TV_NAME_LOOKUP
);
4310 b
= innermost_nonclass_level ();
4312 if (b
->kind
== sk_namespace
)
4314 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4316 /* extern "C" function() */
4317 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4320 else if (IDENTIFIER_BINDING (name
)
4321 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4323 cxx_binding
*binding
;
4324 binding
= IDENTIFIER_BINDING (name
);
4327 if (binding
->scope
== b
4328 && !(TREE_CODE (binding
->value
) == VAR_DECL
4329 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4330 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
->value
);
4332 if (b
->kind
== sk_cleanup
)
4339 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4342 /* Like lookup_name_innermost_nonclass_level, but for types. */
4345 lookup_type_current_level (tree name
)
4349 timevar_push (TV_NAME_LOOKUP
);
4350 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4352 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4353 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4355 struct cp_binding_level
*b
= current_binding_level
;
4358 if (purpose_member (name
, b
->type_shadowed
))
4359 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
4360 REAL_IDENTIFIER_TYPE_VALUE (name
));
4361 if (b
->kind
== sk_cleanup
)
4368 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4371 /* [basic.lookup.koenig] */
4372 /* A nonzero return value in the functions below indicates an error. */
4383 static bool arg_assoc (struct arg_lookup
*, tree
);
4384 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4385 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4386 static bool add_function (struct arg_lookup
*, tree
);
4387 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4388 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4389 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4391 /* Add a function to the lookup structure.
4392 Returns true on error. */
4395 add_function (struct arg_lookup
*k
, tree fn
)
4397 /* We used to check here to see if the function was already in the list,
4398 but that's O(n^2), which is just too expensive for function lookup.
4399 Now we deal with the occasional duplicate in joust. In doing this, we
4400 assume that the number of duplicates will be small compared to the
4401 total number of functions being compared, which should usually be the
4404 /* We must find only functions, or exactly one non-function. */
4407 else if (fn
== k
->functions
)
4409 else if (is_overloaded_fn (k
->functions
) && is_overloaded_fn (fn
))
4410 k
->functions
= build_overload (fn
, k
->functions
);
4413 tree f1
= OVL_CURRENT (k
->functions
);
4415 if (is_overloaded_fn (f1
))
4417 fn
= f1
; f1
= f2
; f2
= fn
;
4419 error ("%q+D is not a function,", f1
);
4420 error (" conflict with %q+D", f2
);
4421 error (" in call to %qD", k
->name
);
4428 /* Returns true iff CURRENT has declared itself to be an associated
4429 namespace of SCOPE via a strong using-directive (or transitive chain
4430 thereof). Both are namespaces. */
4433 is_associated_namespace (tree current
, tree scope
)
4435 tree seen
= NULL_TREE
;
4436 tree todo
= NULL_TREE
;
4440 if (scope
== current
)
4442 seen
= tree_cons (scope
, NULL_TREE
, seen
);
4443 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4444 if (!purpose_member (TREE_PURPOSE (t
), seen
))
4445 todo
= tree_cons (TREE_PURPOSE (t
), NULL_TREE
, todo
);
4448 scope
= TREE_PURPOSE (todo
);
4449 todo
= TREE_CHAIN (todo
);
4456 /* Return whether FN is a friend of an associated class of ARG. */
4459 friend_of_associated_class_p (tree arg
, tree fn
)
4465 else if (type_unknown_p (arg
))
4468 type
= TREE_TYPE (arg
);
4470 /* If TYPE is a class, the class itself and all base classes are
4471 associated classes. */
4472 if (CLASS_TYPE_P (type
))
4474 if (is_friend (type
, fn
))
4477 if (TYPE_BINFO (type
))
4479 tree binfo
, base_binfo
;
4482 for (binfo
= TYPE_BINFO (type
), i
= 0;
4483 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
4485 if (is_friend (BINFO_TYPE (base_binfo
), fn
))
4490 /* If TYPE is a class member, the class of which it is a member is
4491 an associated class. */
4492 if ((CLASS_TYPE_P (type
)
4493 || TREE_CODE (type
) == UNION_TYPE
4494 || TREE_CODE (type
) == ENUMERAL_TYPE
)
4495 && TYPE_CONTEXT (type
)
4496 && CLASS_TYPE_P (TYPE_CONTEXT (type
))
4497 && is_friend (TYPE_CONTEXT (type
), fn
))
4503 /* Add functions of a namespace to the lookup structure.
4504 Returns true on error. */
4507 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4511 if (purpose_member (scope
, k
->namespaces
))
4513 k
->namespaces
= tree_cons (scope
, NULL_TREE
, k
->namespaces
);
4515 /* Check out our super-users. */
4516 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4517 value
= TREE_CHAIN (value
))
4518 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4521 /* Also look down into inline namespaces. */
4522 for (value
= DECL_NAMESPACE_USING (scope
); value
;
4523 value
= TREE_CHAIN (value
))
4524 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
4525 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4528 value
= namespace_binding (k
->name
, scope
);
4532 for (; value
; value
= OVL_NEXT (value
))
4534 /* We don't want to find arbitrary hidden functions via argument
4535 dependent lookup. We only want to find friends of associated
4537 if (hidden_name_p (OVL_CURRENT (value
)))
4541 for (args
= k
->args
; args
; args
= TREE_CHAIN (args
))
4542 if (friend_of_associated_class_p (TREE_VALUE (args
),
4543 OVL_CURRENT (value
)))
4549 if (add_function (k
, OVL_CURRENT (value
)))
4556 /* Adds everything associated with a template argument to the lookup
4557 structure. Returns true on error. */
4560 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4562 /* [basic.lookup.koenig]
4564 If T is a template-id, its associated namespaces and classes are
4565 ... the namespaces and classes associated with the types of the
4566 template arguments provided for template type parameters
4567 (excluding template template parameters); the namespaces in which
4568 any template template arguments are defined; and the classes in
4569 which any member templates used as template template arguments
4570 are defined. [Note: non-type template arguments do not
4571 contribute to the set of associated namespaces. ] */
4573 /* Consider first template template arguments. */
4574 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4575 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
4577 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
4579 tree ctx
= CP_DECL_CONTEXT (arg
);
4581 /* It's not a member template. */
4582 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4583 return arg_assoc_namespace (k
, ctx
);
4584 /* Otherwise, it must be member template. */
4586 return arg_assoc_class (k
, ctx
);
4588 /* It's an argument pack; handle it recursively. */
4589 else if (ARGUMENT_PACK_P (arg
))
4591 tree args
= ARGUMENT_PACK_ARGS (arg
);
4592 int i
, len
= TREE_VEC_LENGTH (args
);
4593 for (i
= 0; i
< len
; ++i
)
4594 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
4599 /* It's not a template template argument, but it is a type template
4601 else if (TYPE_P (arg
))
4602 return arg_assoc_type (k
, arg
);
4603 /* It's a non-type template argument. */
4608 /* Adds everything associated with class to the lookup structure.
4609 Returns true on error. */
4612 arg_assoc_class (struct arg_lookup
*k
, tree type
)
4614 tree list
, friends
, context
;
4617 /* Backend build structures, such as __builtin_va_list, aren't
4618 affected by all this. */
4619 if (!CLASS_TYPE_P (type
))
4622 if (purpose_member (type
, k
->classes
))
4624 k
->classes
= tree_cons (type
, NULL_TREE
, k
->classes
);
4626 context
= decl_namespace_context (type
);
4627 if (arg_assoc_namespace (k
, context
))
4630 if (TYPE_BINFO (type
))
4632 /* Process baseclasses. */
4633 tree binfo
, base_binfo
;
4635 for (binfo
= TYPE_BINFO (type
), i
= 0;
4636 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4637 if (arg_assoc_class (k
, BINFO_TYPE (base_binfo
)))
4641 /* Process friends. */
4642 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
4643 list
= TREE_CHAIN (list
))
4644 if (k
->name
== FRIEND_NAME (list
))
4645 for (friends
= FRIEND_DECLS (list
); friends
;
4646 friends
= TREE_CHAIN (friends
))
4648 tree fn
= TREE_VALUE (friends
);
4650 /* Only interested in global functions with potentially hidden
4651 (i.e. unqualified) declarations. */
4652 if (CP_DECL_CONTEXT (fn
) != context
)
4654 /* Template specializations are never found by name lookup.
4655 (Templates themselves can be found, but not template
4656 specializations.) */
4657 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
4659 if (add_function (k
, fn
))
4663 /* Process template arguments. */
4664 if (CLASSTYPE_TEMPLATE_INFO (type
)
4665 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
4667 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
4668 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
4669 arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
));
4675 /* Adds everything associated with a given type.
4676 Returns 1 on error. */
4679 arg_assoc_type (struct arg_lookup
*k
, tree type
)
4681 /* As we do not get the type of non-type dependent expressions
4682 right, we can end up with such things without a type. */
4686 if (TYPE_PTRMEM_P (type
))
4688 /* Pointer to member: associate class type and value type. */
4689 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
4691 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
4693 else switch (TREE_CODE (type
))
4703 case FIXED_POINT_TYPE
:
4706 if (TYPE_PTRMEMFUNC_P (type
))
4707 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
4708 return arg_assoc_class (k
, type
);
4710 case REFERENCE_TYPE
:
4712 return arg_assoc_type (k
, TREE_TYPE (type
));
4715 return arg_assoc_namespace (k
, decl_namespace_context (type
));
4717 /* The basetype is referenced in the first arg type, so just
4720 /* Associate the parameter types. */
4721 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
4723 /* Associate the return type. */
4724 return arg_assoc_type (k
, TREE_TYPE (type
));
4725 case TEMPLATE_TYPE_PARM
:
4726 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4731 gcc_assert (type
== unknown_type_node
4732 || type
== init_list_type_node
);
4734 case TYPE_PACK_EXPANSION
:
4735 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
4743 /* Adds everything associated with arguments. Returns true on error. */
4746 arg_assoc_args (struct arg_lookup
*k
, tree args
)
4748 for (; args
; args
= TREE_CHAIN (args
))
4749 if (arg_assoc (k
, TREE_VALUE (args
)))
4754 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4757 arg_assoc (struct arg_lookup
*k
, tree n
)
4759 if (n
== error_mark_node
)
4763 return arg_assoc_type (k
, n
);
4765 if (! type_unknown_p (n
))
4766 return arg_assoc_type (k
, TREE_TYPE (n
));
4768 if (TREE_CODE (n
) == ADDR_EXPR
)
4769 n
= TREE_OPERAND (n
, 0);
4770 if (TREE_CODE (n
) == COMPONENT_REF
)
4771 n
= TREE_OPERAND (n
, 1);
4772 if (TREE_CODE (n
) == OFFSET_REF
)
4773 n
= TREE_OPERAND (n
, 1);
4774 while (TREE_CODE (n
) == TREE_LIST
)
4776 if (TREE_CODE (n
) == BASELINK
)
4777 n
= BASELINK_FUNCTIONS (n
);
4779 if (TREE_CODE (n
) == FUNCTION_DECL
)
4780 return arg_assoc_type (k
, TREE_TYPE (n
));
4781 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
4783 /* [basic.lookup.koenig]
4785 If T is a template-id, its associated namespaces and classes
4786 are the namespace in which the template is defined; for
4787 member templates, the member template's class... */
4788 tree templ
= TREE_OPERAND (n
, 0);
4789 tree args
= TREE_OPERAND (n
, 1);
4793 if (TREE_CODE (templ
) == COMPONENT_REF
)
4794 templ
= TREE_OPERAND (templ
, 1);
4796 /* First, the template. There may actually be more than one if
4797 this is an overloaded function template. But, in that case,
4798 we only need the first; all the functions will be in the same
4800 templ
= OVL_CURRENT (templ
);
4802 ctx
= CP_DECL_CONTEXT (templ
);
4804 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4806 if (arg_assoc_namespace (k
, ctx
) == 1)
4809 /* It must be a member template. */
4810 else if (arg_assoc_class (k
, ctx
) == 1)
4813 /* Now the arguments. */
4815 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
4816 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
4819 else if (TREE_CODE (n
) == OVERLOAD
)
4821 for (; n
; n
= OVL_CHAIN (n
))
4822 if (arg_assoc_type (k
, TREE_TYPE (OVL_FUNCTION (n
))))
4829 /* Performs Koenig lookup depending on arguments, where fns
4830 are the functions found in normal lookup. */
4833 lookup_arg_dependent (tree name
, tree fns
, tree args
)
4835 struct arg_lookup k
;
4837 timevar_push (TV_NAME_LOOKUP
);
4839 /* Remove any hidden friend functions from the list of functions
4840 found so far. They will be added back by arg_assoc_class as
4842 fns
= remove_hidden_names (fns
);
4847 k
.classes
= NULL_TREE
;
4849 /* We previously performed an optimization here by setting
4850 NAMESPACES to the current namespace when it was safe. However, DR
4851 164 says that namespaces that were already searched in the first
4852 stage of template processing are searched again (potentially
4853 picking up later definitions) in the second stage. */
4854 k
.namespaces
= NULL_TREE
;
4856 arg_assoc_args (&k
, args
);
4861 && TREE_CODE (fns
) != VAR_DECL
4862 && !is_overloaded_fn (fns
))
4864 error ("argument dependent lookup finds %q+D", fns
);
4865 error (" in call to %qD", name
);
4866 fns
= error_mark_node
;
4869 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, fns
);
4872 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4873 changed (i.e. there was already a directive), or the fresh
4874 TREE_LIST otherwise. */
4877 push_using_directive (tree used
)
4879 tree ud
= current_binding_level
->using_directives
;
4880 tree iter
, ancestor
;
4882 timevar_push (TV_NAME_LOOKUP
);
4883 /* Check if we already have this. */
4884 if (purpose_member (used
, ud
) != NULL_TREE
)
4885 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4887 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4888 ud
= current_binding_level
->using_directives
;
4889 ud
= tree_cons (used
, ancestor
, ud
);
4890 current_binding_level
->using_directives
= ud
;
4892 /* Recursively add all namespaces used. */
4893 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4894 push_using_directive (TREE_PURPOSE (iter
));
4896 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ud
);
4899 /* The type TYPE is being declared. If it is a class template, or a
4900 specialization of a class template, do any processing required and
4901 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4902 being declared a friend. B is the binding level at which this TYPE
4905 Returns the TYPE_DECL for TYPE, which may have been altered by this
4909 maybe_process_template_type_declaration (tree type
, int is_friend
,
4912 tree decl
= TYPE_NAME (type
);
4914 if (processing_template_parmlist
)
4915 /* You can't declare a new template type in a template parameter
4916 list. But, you can declare a non-template type:
4918 template <class A*> struct S;
4920 is a forward-declaration of `A'. */
4922 else if (b
->kind
== sk_namespace
4923 && current_binding_level
->kind
!= sk_namespace
)
4924 /* If this new type is being injected into a containing scope,
4925 then it's not a template type. */
4929 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
4930 || TREE_CODE (type
) == ENUMERAL_TYPE
);
4932 if (processing_template_decl
)
4934 /* This may change after the call to
4935 push_template_decl_real, but we want the original value. */
4936 tree name
= DECL_NAME (decl
);
4938 decl
= push_template_decl_real (decl
, is_friend
);
4939 if (decl
== error_mark_node
)
4940 return error_mark_node
;
4942 /* If the current binding level is the binding level for the
4943 template parameters (see the comment in
4944 begin_template_parm_list) and the enclosing level is a class
4945 scope, and we're not looking at a friend, push the
4946 declaration of the member class into the class scope. In the
4947 friend case, push_template_decl will already have put the
4948 friend into global scope, if appropriate. */
4949 if (TREE_CODE (type
) != ENUMERAL_TYPE
4950 && !is_friend
&& b
->kind
== sk_template_parms
4951 && b
->level_chain
->kind
== sk_class
)
4953 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
4955 if (!COMPLETE_TYPE_P (current_class_type
))
4957 maybe_add_class_template_decl_list (current_class_type
,
4958 type
, /*friend_p=*/0);
4959 /* Put this UTD in the table of UTDs for the class. */
4960 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
4961 CLASSTYPE_NESTED_UTDS (current_class_type
) =
4962 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4964 binding_table_insert
4965 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
4974 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4975 that the NAME is a class template, the tag is processed but not pushed.
4977 The pushed scope depend on the SCOPE parameter:
4978 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4980 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4981 non-template-parameter scope. This case is needed for forward
4983 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4984 TS_GLOBAL case except that names within template-parameter scopes
4985 are not pushed at all.
4987 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4990 pushtag (tree name
, tree type
, tag_scope scope
)
4992 struct cp_binding_level
*b
;
4995 timevar_push (TV_NAME_LOOKUP
);
4996 b
= current_binding_level
;
4997 while (/* Cleanup scopes are not scopes from the point of view of
4999 b
->kind
== sk_cleanup
5000 /* Neither are function parameter scopes. */
5001 || b
->kind
== sk_function_parms
5002 /* Neither are the scopes used to hold template parameters
5003 for an explicit specialization. For an ordinary template
5004 declaration, these scopes are not scopes from the point of
5005 view of the language. */
5006 || (b
->kind
== sk_template_parms
5007 && (b
->explicit_spec_p
|| scope
== ts_global
))
5008 || (b
->kind
== sk_class
5009 && (scope
!= ts_current
5010 /* We may be defining a new type in the initializer
5011 of a static member variable. We allow this when
5012 not pedantic, and it is particularly useful for
5013 type punning via an anonymous union. */
5014 || COMPLETE_TYPE_P (b
->this_entity
))))
5017 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5019 /* Do C++ gratuitous typedefing. */
5020 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
5024 tree context
= TYPE_CONTEXT (type
);
5028 tree cs
= current_scope ();
5030 if (scope
== ts_current
)
5032 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5033 /* When declaring a friend class of a local class, we want
5034 to inject the newly named class into the scope
5035 containing the local class, not the namespace
5037 context
= decl_function_context (get_type_decl (cs
));
5040 context
= current_namespace
;
5042 if (b
->kind
== sk_class
5043 || (b
->kind
== sk_template_parms
5044 && b
->level_chain
->kind
== sk_class
))
5047 if (current_lang_name
== lang_name_java
)
5048 TYPE_FOR_JAVA (type
) = 1;
5050 tdef
= create_implicit_typedef (name
, type
);
5051 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5052 if (scope
== ts_within_enclosing_non_class
)
5054 /* This is a friend. Make this TYPE_DECL node hidden from
5055 ordinary name lookup. Its corresponding TEMPLATE_DECL
5056 will be marked in push_template_decl_real. */
5057 retrofit_lang_decl (tdef
);
5058 DECL_ANTICIPATED (tdef
) = 1;
5059 DECL_FRIEND_P (tdef
) = 1;
5062 decl
= maybe_process_template_type_declaration
5063 (type
, scope
== ts_within_enclosing_non_class
, b
);
5064 if (decl
== error_mark_node
)
5065 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
5067 if (b
->kind
== sk_class
)
5069 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5070 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5071 class. But if it's a member template class, we want
5072 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5074 finish_member_declaration (decl
);
5076 pushdecl_class_level (decl
);
5078 else if (b
->kind
!= sk_template_parms
)
5080 decl
= pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
5081 if (decl
== error_mark_node
)
5082 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
5086 set_identifier_type_value_with_scope (name
, tdef
, b
);
5088 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5090 /* If this is a local class, keep track of it. We need this
5091 information for name-mangling, and so that it is possible to
5092 find all function definitions in a translation unit in a
5093 convenient way. (It's otherwise tricky to find a member
5094 function definition it's only pointed to from within a local
5096 if (TYPE_CONTEXT (type
)
5097 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
5098 VEC_safe_push (tree
, gc
, local_classes
, type
);
5100 if (b
->kind
== sk_class
5101 && !COMPLETE_TYPE_P (current_class_type
))
5103 maybe_add_class_template_decl_list (current_class_type
,
5104 type
, /*friend_p=*/0);
5106 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5107 CLASSTYPE_NESTED_UTDS (current_class_type
)
5108 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5110 binding_table_insert
5111 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5114 decl
= TYPE_NAME (type
);
5115 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
5116 TYPE_STUB_DECL (type
) = decl
;
5118 /* Set type visibility now if this is a forward declaration. */
5119 TREE_PUBLIC (decl
) = 1;
5120 determine_visibility (decl
);
5122 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, type
);
5125 /* Subroutines for reverting temporarily to top-level for instantiation
5126 of templates and such. We actually need to clear out the class- and
5127 local-value slots of all identifiers, so that only the global values
5128 are at all visible. Simply setting current_binding_level to the global
5129 scope isn't enough, because more binding levels may be pushed. */
5130 struct saved_scope
*scope_chain
;
5132 /* If ID has not already been marked, add an appropriate binding to
5136 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5138 cxx_saved_binding
*saved
;
5140 if (!id
|| !IDENTIFIER_BINDING (id
))
5143 if (IDENTIFIER_MARKED (id
))
5146 IDENTIFIER_MARKED (id
) = 1;
5148 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
5149 saved
->identifier
= id
;
5150 saved
->binding
= IDENTIFIER_BINDING (id
);
5151 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
5152 IDENTIFIER_BINDING (id
) = NULL
;
5156 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5160 timevar_push (TV_NAME_LOOKUP
);
5161 for (t
= names
; t
; t
= TREE_CHAIN (t
))
5165 if (TREE_CODE (t
) == TREE_LIST
)
5166 id
= TREE_PURPOSE (t
);
5170 store_binding (id
, old_bindings
);
5172 timevar_pop (TV_NAME_LOOKUP
);
5175 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5176 objects, rather than a TREE_LIST. */
5179 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
5180 VEC(cxx_saved_binding
,gc
) **old_bindings
)
5183 cp_class_binding
*cb
;
5185 timevar_push (TV_NAME_LOOKUP
);
5186 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
5187 store_binding (cb
->identifier
, old_bindings
);
5188 timevar_pop (TV_NAME_LOOKUP
);
5192 push_to_top_level (void)
5194 struct saved_scope
*s
;
5195 struct cp_binding_level
*b
;
5196 cxx_saved_binding
*sb
;
5200 timevar_push (TV_NAME_LOOKUP
);
5201 s
= GGC_CNEW (struct saved_scope
);
5203 b
= scope_chain
? current_binding_level
: 0;
5205 /* If we're in the middle of some function, save our state. */
5209 push_function_context ();
5214 if (scope_chain
&& previous_class_level
)
5215 store_class_bindings (previous_class_level
->class_shadowed
,
5218 /* Have to include the global scope, because class-scope decls
5219 aren't listed anywhere useful. */
5220 for (; b
; b
= b
->level_chain
)
5224 /* Template IDs are inserted into the global level. If they were
5225 inserted into namespace level, finish_file wouldn't find them
5226 when doing pending instantiations. Therefore, don't stop at
5227 namespace level, but continue until :: . */
5228 if (global_scope_p (b
))
5231 store_bindings (b
->names
, &s
->old_bindings
);
5232 /* We also need to check class_shadowed to save class-level type
5233 bindings, since pushclass doesn't fill in b->names. */
5234 if (b
->kind
== sk_class
)
5235 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
5237 /* Unwind type-value slots back to top level. */
5238 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
5239 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
5242 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, sb
); ++i
)
5243 IDENTIFIER_MARKED (sb
->identifier
) = 0;
5245 s
->prev
= scope_chain
;
5247 s
->need_pop_function_context
= need_pop
;
5248 s
->function_decl
= current_function_decl
;
5249 s
->skip_evaluation
= skip_evaluation
;
5252 current_function_decl
= NULL_TREE
;
5253 current_lang_base
= VEC_alloc (tree
, gc
, 10);
5254 current_lang_name
= lang_name_cplusplus
;
5255 current_namespace
= global_namespace
;
5256 push_class_stack ();
5257 skip_evaluation
= 0;
5258 timevar_pop (TV_NAME_LOOKUP
);
5262 pop_from_top_level (void)
5264 struct saved_scope
*s
= scope_chain
;
5265 cxx_saved_binding
*saved
;
5268 timevar_push (TV_NAME_LOOKUP
);
5269 /* Clear out class-level bindings cache. */
5270 if (previous_class_level
)
5271 invalidate_class_lookup_cache ();
5274 current_lang_base
= 0;
5276 scope_chain
= s
->prev
;
5277 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, saved
); ++i
)
5279 tree id
= saved
->identifier
;
5281 IDENTIFIER_BINDING (id
) = saved
->binding
;
5282 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
5285 /* If we were in the middle of compiling a function, restore our
5287 if (s
->need_pop_function_context
)
5288 pop_function_context ();
5289 current_function_decl
= s
->function_decl
;
5290 skip_evaluation
= s
->skip_evaluation
;
5291 timevar_pop (TV_NAME_LOOKUP
);
5294 /* Pop off extraneous binding levels left over due to syntax errors.
5296 We don't pop past namespaces, as they might be valid. */
5299 pop_everything (void)
5301 if (ENABLE_SCOPE_CHECKING
)
5302 verbatim ("XXX entering pop_everything ()\n");
5303 while (!toplevel_bindings_p ())
5305 if (current_binding_level
->kind
== sk_class
)
5306 pop_nested_class ();
5310 if (ENABLE_SCOPE_CHECKING
)
5311 verbatim ("XXX leaving pop_everything ()\n");
5314 /* Emit debugging information for using declarations and directives.
5315 If input tree is overloaded fn then emit debug info for all
5319 cp_emit_debug_info_for_using (tree t
, tree context
)
5321 /* Don't try to emit any debug information if we have errors. */
5322 if (sorrycount
|| errorcount
)
5325 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5326 of a builtin function. */
5327 if (TREE_CODE (t
) == FUNCTION_DECL
5328 && DECL_EXTERNAL (t
)
5329 && DECL_BUILT_IN (t
))
5332 /* Do not supply context to imported_module_or_decl, if
5333 it is a global namespace. */
5334 if (context
== global_namespace
)
5335 context
= NULL_TREE
;
5338 t
= BASELINK_FUNCTIONS (t
);
5340 /* FIXME: Handle TEMPLATE_DECLs. */
5341 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
5342 if (TREE_CODE (t
) != TEMPLATE_DECL
)
5343 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
5346 #include "gt-cp-name-lookup.h"