1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 GTY(()) binding_table_s
{
129 /* Array of chains of "binding_entry"s */
130 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
132 /* The number of chains in this table. This is the length of the
133 member "chain" considered as an array. */
136 /* Number of "binding_entry"s in this table. */
140 /* Construct TABLE with an initial CHAIN_COUNT. */
143 binding_table_construct (binding_table table
, size_t chain_count
)
145 table
->chain_count
= chain_count
;
146 table
->entry_count
= 0;
147 table
->chain
= GGC_CNEWVEC (binding_entry
, table
->chain_count
);
150 /* Make TABLE's entries ready for reuse. */
153 binding_table_free (binding_table table
)
161 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
163 binding_entry temp
= table
->chain
[i
];
166 binding_entry entry
= temp
;
168 binding_entry_free (entry
);
170 table
->chain
[i
] = NULL
;
172 table
->entry_count
= 0;
176 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
178 static inline binding_table
179 binding_table_new (size_t chain_count
)
181 binding_table table
= GGC_NEW (struct binding_table_s
);
183 binding_table_construct (table
, chain_count
);
187 /* Expand TABLE to twice its current chain_count. */
190 binding_table_expand (binding_table table
)
192 const size_t old_chain_count
= table
->chain_count
;
193 const size_t old_entry_count
= table
->entry_count
;
194 const size_t new_chain_count
= 2 * old_chain_count
;
195 binding_entry
*old_chains
= table
->chain
;
198 binding_table_construct (table
, new_chain_count
);
199 for (i
= 0; i
< old_chain_count
; ++i
)
201 binding_entry entry
= old_chains
[i
];
202 for (; entry
!= NULL
; entry
= old_chains
[i
])
204 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
205 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
207 old_chains
[i
] = entry
->chain
;
208 entry
->chain
= table
->chain
[j
];
209 table
->chain
[j
] = entry
;
212 table
->entry_count
= old_entry_count
;
215 /* Insert a binding for NAME to TYPE into TABLE. */
218 binding_table_insert (binding_table table
, tree name
, tree type
)
220 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
221 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
222 binding_entry entry
= binding_entry_make (name
, type
);
224 entry
->chain
= table
->chain
[i
];
225 table
->chain
[i
] = entry
;
226 ++table
->entry_count
;
228 if (3 * table
->chain_count
< 5 * table
->entry_count
)
229 binding_table_expand (table
);
232 /* Return the binding_entry, if any, that maps NAME. */
235 binding_table_find (binding_table table
, tree name
)
237 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
238 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
240 while (entry
!= NULL
&& entry
->name
!= name
)
241 entry
= entry
->chain
;
246 /* Apply PROC -- with DATA -- to all entries in TABLE. */
249 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
251 const size_t chain_count
= table
->chain_count
;
254 for (i
= 0; i
< chain_count
; ++i
)
256 binding_entry entry
= table
->chain
[i
];
257 for (; entry
!= NULL
; entry
= entry
->chain
)
262 #ifndef ENABLE_SCOPE_CHECKING
263 # define ENABLE_SCOPE_CHECKING 0
265 # define ENABLE_SCOPE_CHECKING 1
268 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
270 static GTY((deletable
)) cxx_binding
*free_bindings
;
272 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
276 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
278 binding
->value
= value
;
279 binding
->type
= type
;
280 binding
->previous
= NULL
;
283 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
286 cxx_binding_make (tree value
, tree type
)
288 cxx_binding
*binding
;
291 binding
= free_bindings
;
292 free_bindings
= binding
->previous
;
295 binding
= GGC_NEW (cxx_binding
);
297 cxx_binding_init (binding
, value
, type
);
302 /* Put BINDING back on the free list. */
305 cxx_binding_free (cxx_binding
*binding
)
307 binding
->scope
= NULL
;
308 binding
->previous
= free_bindings
;
309 free_bindings
= binding
;
312 /* Create a new binding for NAME (with the indicated VALUE and TYPE
313 bindings) in the class scope indicated by SCOPE. */
316 new_class_binding (tree name
, tree value
, tree type
, cxx_scope
*scope
)
318 cp_class_binding
*cb
;
319 cxx_binding
*binding
;
321 if (VEC_length (cp_class_binding
, scope
->class_shadowed
))
323 cp_class_binding
*old_base
;
324 old_base
= VEC_index (cp_class_binding
, scope
->class_shadowed
, 0);
325 if (VEC_reserve (cp_class_binding
, gc
, scope
->class_shadowed
, 1))
327 /* Fixup the current bindings, as they might have moved. */
331 VEC_iterate (cp_class_binding
, scope
->class_shadowed
, i
, cb
);
335 b
= &IDENTIFIER_BINDING (cb
->identifier
);
336 while (*b
!= &old_base
[i
].base
)
337 b
= &((*b
)->previous
);
341 cb
= VEC_quick_push (cp_class_binding
, scope
->class_shadowed
, NULL
);
344 cb
= VEC_safe_push (cp_class_binding
, gc
, scope
->class_shadowed
, NULL
);
346 cb
->identifier
= name
;
348 binding
->scope
= scope
;
349 cxx_binding_init (binding
, value
, type
);
353 /* Make DECL the innermost binding for ID. The LEVEL is the binding
354 level at which this declaration is being bound. */
357 push_binding (tree id
, tree decl
, cxx_scope
* level
)
359 cxx_binding
*binding
;
361 if (level
!= class_binding_level
)
363 binding
= cxx_binding_make (decl
, NULL_TREE
);
364 binding
->scope
= level
;
367 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
369 /* Now, fill in the binding information. */
370 binding
->previous
= IDENTIFIER_BINDING (id
);
371 INHERITED_VALUE_BINDING_P (binding
) = 0;
372 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
374 /* And put it on the front of the list of bindings for ID. */
375 IDENTIFIER_BINDING (id
) = binding
;
378 /* Remove the binding for DECL which should be the innermost binding
382 pop_binding (tree id
, tree decl
)
384 cxx_binding
*binding
;
387 /* It's easiest to write the loops that call this function without
388 checking whether or not the entities involved have names. We
389 get here for such an entity. */
392 /* Get the innermost binding for ID. */
393 binding
= IDENTIFIER_BINDING (id
);
395 /* The name should be bound. */
396 gcc_assert (binding
!= NULL
);
398 /* The DECL will be either the ordinary binding or the type
399 binding for this identifier. Remove that binding. */
400 if (binding
->value
== decl
)
401 binding
->value
= NULL_TREE
;
404 gcc_assert (binding
->type
== decl
);
405 binding
->type
= NULL_TREE
;
408 if (!binding
->value
&& !binding
->type
)
410 /* We're completely done with the innermost binding for this
411 identifier. Unhook it from the list of bindings. */
412 IDENTIFIER_BINDING (id
) = binding
->previous
;
414 /* Add it to the free list. */
415 cxx_binding_free (binding
);
419 /* BINDING records an existing declaration for a name in the current scope.
420 But, DECL is another declaration for that same identifier in the
421 same scope. This is the `struct stat' hack whereby a non-typedef
422 class name or enum-name can be bound at the same level as some other
426 A class name (9.1) or enumeration name (7.2) can be hidden by the
427 name of an object, function, or enumerator declared in the same scope.
428 If a class or enumeration name and an object, function, or enumerator
429 are declared in the same scope (in any order) with the same name, the
430 class or enumeration name is hidden wherever the object, function, or
431 enumerator name is visible.
433 It's the responsibility of the caller to check that
434 inserting this name is valid here. Returns nonzero if the new binding
438 supplement_binding (cxx_binding
*binding
, tree decl
)
440 tree bval
= binding
->value
;
443 timevar_push (TV_NAME_LOOKUP
);
444 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
445 /* The new name is the type name. */
446 binding
->type
= decl
;
447 else if (/* BVAL is null when push_class_level_binding moves an
448 inherited type-binding out of the way to make room for a
449 new value binding. */
451 /* BVAL is error_mark_node when DECL's name has been used
452 in a non-class scope prior declaration. In that case,
453 we should have already issued a diagnostic; for graceful
454 error recovery purpose, pretend this was the intended
455 declaration for that name. */
456 || bval
== error_mark_node
457 /* If BVAL is anticipated but has not yet been declared,
458 pretend it is not there at all. */
459 || (TREE_CODE (bval
) == FUNCTION_DECL
460 && DECL_ANTICIPATED (bval
)
461 && !DECL_HIDDEN_FRIEND_P (bval
)))
462 binding
->value
= decl
;
463 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
465 /* The old binding was a type name. It was placed in
466 VALUE field because it was thought, at the point it was
467 declared, to be the only entity with such a name. Move the
468 type name into the type slot; it is now hidden by the new
470 binding
->type
= bval
;
471 binding
->value
= decl
;
472 binding
->value_is_inherited
= false;
474 else if (TREE_CODE (bval
) == TYPE_DECL
475 && TREE_CODE (decl
) == TYPE_DECL
476 && DECL_NAME (decl
) == DECL_NAME (bval
)
477 && binding
->scope
->kind
!= sk_class
478 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
479 /* If either type involves template parameters, we must
480 wait until instantiation. */
481 || uses_template_parms (TREE_TYPE (decl
))
482 || uses_template_parms (TREE_TYPE (bval
))))
483 /* We have two typedef-names, both naming the same type to have
484 the same name. In general, this is OK because of:
488 In a given scope, a typedef specifier can be used to redefine
489 the name of any type declared in that scope to refer to the
490 type to which it already refers.
492 However, in class scopes, this rule does not apply due to the
493 stricter language in [class.mem] prohibiting redeclarations of
496 /* There can be two block-scope declarations of the same variable,
497 so long as they are `extern' declarations. However, there cannot
498 be two declarations of the same static data member:
502 A member shall not be declared twice in the
503 member-specification. */
504 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
505 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
506 && !DECL_CLASS_SCOPE_P (decl
))
508 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
511 else if (TREE_CODE (decl
) == NAMESPACE_DECL
512 && TREE_CODE (bval
) == NAMESPACE_DECL
513 && DECL_NAMESPACE_ALIAS (decl
)
514 && DECL_NAMESPACE_ALIAS (bval
)
515 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
518 In a declarative region, a namespace-alias-definition can be
519 used to redefine a namespace-alias declared in that declarative
520 region to refer only to the namespace to which it already
525 error ("declaration of %q#D", decl
);
526 error ("conflicts with previous declaration %q+#D", bval
);
530 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
533 /* Add DECL to the list of things declared in B. */
536 add_decl_to_level (tree decl
, cxx_scope
*b
)
538 /* We used to record virtual tables as if they were ordinary
539 variables, but no longer do so. */
540 gcc_assert (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
)));
542 if (TREE_CODE (decl
) == NAMESPACE_DECL
543 && !DECL_NAMESPACE_ALIAS (decl
))
545 TREE_CHAIN (decl
) = b
->namespaces
;
546 b
->namespaces
= decl
;
550 /* We build up the list in reverse order, and reverse it later if
552 TREE_CHAIN (decl
) = b
->names
;
556 /* If appropriate, add decl to separate list of statics. We
557 include extern variables because they might turn out to be
558 static later. It's OK for this list to contain a few false
560 if (b
->kind
== sk_namespace
)
561 if ((TREE_CODE (decl
) == VAR_DECL
562 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
563 || (TREE_CODE (decl
) == FUNCTION_DECL
564 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
565 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
569 /* Record a decl-node X as belonging to the current lexical scope.
570 Check for errors (such as an incompatible declaration for the same
571 name already seen in the same scope). IS_FRIEND is true if X is
572 declared as a friend.
574 Returns either X or an old decl for the same name.
575 If an old decl is returned, it may have been smashed
576 to agree with what X says. */
579 pushdecl_maybe_friend (tree x
, bool is_friend
)
583 int need_new_binding
;
585 timevar_push (TV_NAME_LOOKUP
);
587 if (x
== error_mark_node
)
588 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
590 need_new_binding
= 1;
592 if (DECL_TEMPLATE_PARM_P (x
))
593 /* Template parameters have no context; they are not X::T even
594 when declared within a class or namespace. */
598 if (current_function_decl
&& x
!= current_function_decl
599 /* A local declaration for a function doesn't constitute
601 && TREE_CODE (x
) != FUNCTION_DECL
602 /* A local declaration for an `extern' variable is in the
603 scope of the current namespace, not the current
605 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
606 /* When parsing the parameter list of a function declarator,
607 don't set DECL_CONTEXT to an enclosing function. When we
608 push the PARM_DECLs in order to process the function body,
609 current_binding_level->this_entity will be set. */
610 && !(TREE_CODE (x
) == PARM_DECL
611 && current_binding_level
->kind
== sk_function_parms
612 && current_binding_level
->this_entity
== NULL
)
613 && !DECL_CONTEXT (x
))
614 DECL_CONTEXT (x
) = current_function_decl
;
616 /* If this is the declaration for a namespace-scope function,
617 but the declaration itself is in a local scope, mark the
619 if (TREE_CODE (x
) == FUNCTION_DECL
620 && DECL_NAMESPACE_SCOPE_P (x
)
621 && current_function_decl
622 && x
!= current_function_decl
)
623 DECL_LOCAL_FUNCTION_P (x
) = 1;
626 name
= DECL_NAME (x
);
629 int different_binding_level
= 0;
631 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
632 name
= TREE_OPERAND (name
, 0);
634 /* In case this decl was explicitly namespace-qualified, look it
635 up in its namespace context. */
636 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
637 t
= namespace_binding (name
, DECL_CONTEXT (x
));
639 t
= lookup_name_innermost_nonclass_level (name
);
641 /* [basic.link] If there is a visible declaration of an entity
642 with linkage having the same name and type, ignoring entities
643 declared outside the innermost enclosing namespace scope, the
644 block scope declaration declares that same entity and
645 receives the linkage of the previous declaration. */
646 if (! t
&& current_function_decl
&& x
!= current_function_decl
647 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
648 && DECL_EXTERNAL (x
))
650 /* Look in block scope. */
651 t
= innermost_non_namespace_value (name
);
652 /* Or in the innermost namespace. */
654 t
= namespace_binding (name
, DECL_CONTEXT (x
));
655 /* Does it have linkage? Note that if this isn't a DECL, it's an
656 OVERLOAD, which is OK. */
657 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
660 different_binding_level
= 1;
663 /* If we are declaring a function, and the result of name-lookup
664 was an OVERLOAD, look for an overloaded instance that is
665 actually the same as the function we are declaring. (If
666 there is one, we have to merge our declaration with the
667 previous declaration.) */
668 if (t
&& TREE_CODE (t
) == OVERLOAD
)
672 if (TREE_CODE (x
) == FUNCTION_DECL
)
673 for (match
= t
; match
; match
= OVL_NEXT (match
))
675 if (decls_match (OVL_CURRENT (match
), x
))
679 /* Just choose one. */
683 t
= OVL_CURRENT (match
);
688 if (t
&& t
!= error_mark_node
)
690 if (different_binding_level
)
692 if (decls_match (x
, t
))
693 /* The standard only says that the local extern
694 inherits linkage from the previous decl; in
695 particular, default args are not shared. Add
696 the decl into a hash table to make sure only
697 the previous decl in this case is seen by the
700 struct cxx_int_tree_map
*h
;
703 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
705 if (cp_function_chain
->extern_decl_map
== NULL
)
706 cp_function_chain
->extern_decl_map
707 = htab_create_ggc (20, cxx_int_tree_map_hash
,
708 cxx_int_tree_map_eq
, NULL
);
710 h
= GGC_NEW (struct cxx_int_tree_map
);
711 h
->uid
= DECL_UID (x
);
713 loc
= htab_find_slot_with_hash
714 (cp_function_chain
->extern_decl_map
, h
,
716 *(struct cxx_int_tree_map
**) loc
= h
;
719 else if (TREE_CODE (t
) == PARM_DECL
)
721 /* Check for duplicate params. */
722 tree d
= duplicate_decls (x
, t
, is_friend
);
724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, d
);
726 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
727 || DECL_FUNCTION_TEMPLATE_P (x
))
728 && is_overloaded_fn (t
))
729 /* Don't do anything just yet. */;
730 else if (t
== wchar_decl_node
)
732 if (! DECL_IN_SYSTEM_HEADER (x
))
733 pedwarn (input_location
, OPT_pedantic
, "redeclaration of %<wchar_t%> as %qT",
736 /* Throw away the redeclaration. */
737 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
741 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
743 /* If the redeclaration failed, we can stop at this
745 if (olddecl
== error_mark_node
)
746 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
750 if (TREE_CODE (t
) == TYPE_DECL
)
751 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
753 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
755 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
757 /* A redeclaration of main, but not a duplicate of the
762 This function shall not be overloaded. */
763 error ("invalid redeclaration of %q+D", t
);
765 /* We don't try to push this declaration since that
767 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
772 /* If x has C linkage-specification, (extern "C"),
773 lookup its binding, in case it's already bound to an object.
774 The lookup is done in all namespaces.
775 If we find an existing binding, make sure it has the same
776 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
777 if ((TREE_CODE (x
) == FUNCTION_DECL
)
778 && DECL_EXTERN_C_P (x
)
779 /* We should ignore declarations happening in system headers. */
780 && !DECL_ARTIFICIAL (x
)
781 && !DECL_IN_SYSTEM_HEADER (x
))
783 cxx_binding
*function_binding
=
784 lookup_extern_c_fun_binding_in_all_ns (x
);
785 tree previous
= (function_binding
786 ? function_binding
->value
789 && !DECL_ARTIFICIAL (previous
)
790 && !DECL_IN_SYSTEM_HEADER (previous
)
791 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
793 tree previous
= function_binding
->value
;
795 /* In case either x or previous is declared to throw an exception,
796 make sure both exception specifications are equal. */
797 if (decls_match (x
, previous
))
799 tree x_exception_spec
= NULL_TREE
;
800 tree previous_exception_spec
= NULL_TREE
;
803 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
804 previous_exception_spec
=
805 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
806 if (!comp_except_specs (previous_exception_spec
,
810 pedwarn (input_location
, 0, "declaration of %q#D with C language linkage",
812 pedwarn (input_location
, 0, "conflicts with previous declaration %q+#D",
814 pedwarn (input_location
, 0, "due to different exception specifications");
815 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
820 pedwarn (input_location
, 0,
821 "declaration of %q#D with C language linkage", x
);
822 pedwarn (input_location
, 0,
823 "conflicts with previous declaration %q+#D",
829 check_template_shadow (x
);
831 /* If this is a function conjured up by the back end, massage it
832 so it looks friendly. */
833 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
835 retrofit_lang_decl (x
);
836 SET_DECL_LANGUAGE (x
, lang_c
);
840 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
842 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
843 if (!namespace_bindings_p ())
844 /* We do not need to create a binding for this name;
845 push_overloaded_decl will have already done so if
847 need_new_binding
= 0;
849 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
851 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
853 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
856 if (TREE_CODE (x
) == FUNCTION_DECL
|| DECL_FUNCTION_TEMPLATE_P (x
))
857 check_default_args (x
);
859 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
860 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
862 /* If declaring a type as a typedef, copy the type (unless we're
863 at line 0), and install this TYPE_DECL as the new type's typedef
864 name. See the extensive comment of set_underlying_type (). */
865 if (TREE_CODE (x
) == TYPE_DECL
)
867 tree type
= TREE_TYPE (x
);
869 if (DECL_IS_BUILTIN (x
)
870 || (TREE_TYPE (x
) != error_mark_node
871 && TYPE_NAME (type
) != x
872 /* We don't want to copy the type when all we're
873 doing is making a TYPE_DECL for the purposes of
875 && (!TYPE_NAME (type
)
876 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
877 set_underlying_type (x
);
879 if (type
!= error_mark_node
881 && TYPE_IDENTIFIER (type
))
882 set_identifier_type_value (DECL_NAME (x
), x
);
885 /* Multiple external decls of the same identifier ought to match.
887 We get warnings about inline functions where they are defined.
888 We get warnings about other functions from push_overloaded_decl.
890 Avoid duplicate warnings where they are used. */
891 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
895 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
896 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
897 decl
= OVL_FUNCTION (decl
);
899 if (decl
&& decl
!= error_mark_node
900 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
901 /* If different sort of thing, we already gave an error. */
902 && TREE_CODE (decl
) == TREE_CODE (x
)
903 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
905 permerror (input_location
, "type mismatch with previous external decl of %q#D", x
);
906 permerror (input_location
, "previous external decl of %q+#D", decl
);
910 if (TREE_CODE (x
) == FUNCTION_DECL
912 && !flag_friend_injection
)
914 /* This is a new declaration of a friend function, so hide
915 it from ordinary function lookup. */
916 DECL_ANTICIPATED (x
) = 1;
917 DECL_HIDDEN_FRIEND_P (x
) = 1;
920 /* This name is new in its binding level.
921 Install the new declaration and return it. */
922 if (namespace_bindings_p ())
924 /* Install a global value. */
926 /* If the first global decl has external linkage,
927 warn if we later see static one. */
928 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
929 TREE_PUBLIC (name
) = 1;
931 /* Bind the name for the entity. */
932 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
934 && (TREE_CODE (x
) == TYPE_DECL
935 || TREE_CODE (x
) == VAR_DECL
936 || TREE_CODE (x
) == NAMESPACE_DECL
937 || TREE_CODE (x
) == CONST_DECL
938 || TREE_CODE (x
) == TEMPLATE_DECL
))
939 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
941 /* If new decl is `static' and an `extern' was seen previously,
943 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
944 warn_extern_redeclared_static (x
, t
);
948 /* Here to install a non-global value. */
949 tree oldlocal
= innermost_non_namespace_value (name
);
950 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
952 if (need_new_binding
)
954 push_local_binding (name
, x
, 0);
955 /* Because push_local_binding will hook X on to the
956 current_binding_level's name list, we don't want to
957 do that again below. */
958 need_new_binding
= 0;
961 /* If this is a TYPE_DECL, push it into the type value slot. */
962 if (TREE_CODE (x
) == TYPE_DECL
)
963 set_identifier_type_value (name
, x
);
965 /* Clear out any TYPE_DECL shadowed by a namespace so that
966 we won't think this is a type. The C struct hack doesn't
967 go through namespaces. */
968 if (TREE_CODE (x
) == NAMESPACE_DECL
)
969 set_identifier_type_value (name
, NULL_TREE
);
976 && TREE_CODE (oldlocal
) == VAR_DECL
977 && DECL_DEAD_FOR_LOCAL (oldlocal
))
978 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
980 if (oldlocal
== NULL_TREE
)
981 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
984 /* If this is an extern function declaration, see if we
985 have a global definition or declaration for the function. */
986 if (oldlocal
== NULL_TREE
988 && oldglobal
!= NULL_TREE
989 && TREE_CODE (x
) == FUNCTION_DECL
990 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
992 /* We have one. Their types must agree. */
993 if (decls_match (x
, oldglobal
))
997 warning (0, "extern declaration of %q#D doesn't match", x
);
998 warning (0, "global declaration %q+#D", oldglobal
);
1001 /* If we have a local external declaration,
1002 and no file-scope declaration has yet been seen,
1003 then if we later have a file-scope decl it must not be static. */
1004 if (oldlocal
== NULL_TREE
1005 && oldglobal
== NULL_TREE
1006 && DECL_EXTERNAL (x
)
1008 TREE_PUBLIC (name
) = 1;
1010 /* Don't complain about the parms we push and then pop
1011 while tentatively parsing a function declarator. */
1012 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1015 /* Warn if shadowing an argument at the top level of the body. */
1016 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1017 /* Inline decls shadow nothing. */
1018 && !DECL_FROM_INLINE (x
)
1019 && TREE_CODE (oldlocal
) == PARM_DECL
1020 /* Don't check the `this' parameter. */
1021 && !DECL_ARTIFICIAL (oldlocal
))
1025 /* Don't complain if it's from an enclosing function. */
1026 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1027 && TREE_CODE (x
) != PARM_DECL
)
1029 /* Go to where the parms should be and see if we find
1031 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
1033 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1034 /* Skip the ctor/dtor cleanup level. */
1038 if (b
->kind
== sk_function_parms
)
1040 error ("declaration of %q#D shadows a parameter", x
);
1045 if (warn_shadow
&& !err
)
1047 warning (OPT_Wshadow
, "declaration of %q#D shadows a parameter", x
);
1048 warning (OPT_Wshadow
, "%Jshadowed declaration is here", oldlocal
);
1052 /* Maybe warn if shadowing something else. */
1053 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1054 /* No shadow warnings for internally generated vars. */
1055 && ! DECL_ARTIFICIAL (x
)
1056 /* No shadow warnings for vars made for inlining. */
1057 && ! DECL_FROM_INLINE (x
))
1061 if (current_class_ptr
)
1062 member
= lookup_member (current_class_type
,
1065 /*want_type=*/false);
1069 if (member
&& !TREE_STATIC (member
))
1071 /* Location of previous decl is not useful in this case. */
1072 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
1075 else if (oldlocal
!= NULL_TREE
1076 && TREE_CODE (oldlocal
) == VAR_DECL
)
1078 warning (OPT_Wshadow
, "declaration of %qD shadows a previous local", x
);
1079 warning (OPT_Wshadow
, "%Jshadowed declaration is here", oldlocal
);
1081 else if (oldglobal
!= NULL_TREE
1082 && TREE_CODE (oldglobal
) == VAR_DECL
)
1083 /* XXX shadow warnings in outer-more namespaces */
1085 warning (OPT_Wshadow
, "declaration of %qD shadows a global declaration",
1087 warning (OPT_Wshadow
, "%Jshadowed declaration is here", oldglobal
);
1092 if (TREE_CODE (x
) == VAR_DECL
)
1093 maybe_register_incomplete_var (x
);
1096 if (need_new_binding
)
1097 add_decl_to_level (x
,
1098 DECL_NAMESPACE_SCOPE_P (x
)
1099 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1100 : current_binding_level
);
1102 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1105 /* Record a decl-node X as belonging to the current lexical scope. */
1110 return pushdecl_maybe_friend (x
, false);
1113 /* Enter DECL into the symbol table, if that's appropriate. Returns
1114 DECL, or a modified version thereof. */
1117 maybe_push_decl (tree decl
)
1119 tree type
= TREE_TYPE (decl
);
1121 /* Add this decl to the current binding level, but not if it comes
1122 from another scope, e.g. a static member variable. TEM may equal
1123 DECL or it may be a previous decl of the same name. */
1124 if (decl
== error_mark_node
1125 || (TREE_CODE (decl
) != PARM_DECL
1126 && DECL_CONTEXT (decl
) != NULL_TREE
1127 /* Definitions of namespace members outside their namespace are
1129 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
1130 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1131 || TREE_CODE (type
) == UNKNOWN_TYPE
1132 /* The declaration of a template specialization does not affect
1133 the functions available for overload resolution, so we do not
1135 || (TREE_CODE (decl
) == FUNCTION_DECL
1136 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1139 return pushdecl (decl
);
1142 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1143 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1144 doesn't really belong to this binding level, that it got here
1145 through a using-declaration. */
1148 push_local_binding (tree id
, tree decl
, int flags
)
1150 struct cp_binding_level
*b
;
1152 /* Skip over any local classes. This makes sense if we call
1153 push_local_binding with a friend decl of a local class. */
1154 b
= innermost_nonclass_level ();
1156 if (lookup_name_innermost_nonclass_level (id
))
1158 /* Supplement the existing binding. */
1159 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1160 /* It didn't work. Something else must be bound at this
1161 level. Do not add DECL to the list of things to pop
1166 /* Create a new binding. */
1167 push_binding (id
, decl
, b
);
1169 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1170 /* We must put the OVERLOAD into a TREE_LIST since the
1171 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1172 decls that got here through a using-declaration. */
1173 decl
= build_tree_list (NULL_TREE
, decl
);
1175 /* And put DECL on the list of things declared by the current
1177 add_decl_to_level (decl
, b
);
1180 /* Check to see whether or not DECL is a variable that would have been
1181 in scope under the ARM, but is not in scope under the ANSI/ISO
1182 standard. If so, issue an error message. If name lookup would
1183 work in both cases, but return a different result, this function
1184 returns the result of ANSI/ISO lookup. Otherwise, it returns
1188 check_for_out_of_scope_variable (tree decl
)
1192 /* We only care about out of scope variables. */
1193 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1196 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1197 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1198 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1199 && DECL_DEAD_FOR_LOCAL (shadowed
))
1200 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1201 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1203 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1206 if (!DECL_ERROR_REPORTED (decl
))
1208 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1209 warning (0, " matches this %q+D under ISO standard rules",
1211 warning (0, " matches this %q+D under old rules", decl
);
1212 DECL_ERROR_REPORTED (decl
) = 1;
1217 /* If we have already complained about this declaration, there's no
1218 need to do it again. */
1219 if (DECL_ERROR_REPORTED (decl
))
1222 DECL_ERROR_REPORTED (decl
) = 1;
1224 if (TREE_TYPE (decl
) == error_mark_node
)
1227 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1229 error ("name lookup of %qD changed for ISO %<for%> scoping",
1231 error (" cannot use obsolete binding at %q+D because "
1232 "it has a destructor", decl
);
1233 return error_mark_node
;
1237 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1239 if (flag_permissive
)
1240 permerror (input_location
, " using obsolete binding at %q+D", decl
);
1246 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1255 /* true means unconditionally make a BLOCK for the next level pushed. */
1257 static bool keep_next_level_flag
;
1259 static int binding_depth
= 0;
1260 static int is_class_level
= 0;
1267 for (i
= 0; i
< depth
* 2; i
++)
1271 /* Return a string describing the kind of SCOPE we have. */
1273 cxx_scope_descriptor (cxx_scope
*scope
)
1275 /* The order of this table must match the "scope_kind"
1277 static const char* scope_kind_names
[] = {
1283 "function-parameter-scope",
1286 "template-parameter-scope",
1287 "template-explicit-spec-scope"
1289 const scope_kind kind
= scope
->explicit_spec_p
1290 ? sk_template_spec
: scope
->kind
;
1292 return scope_kind_names
[kind
];
1295 /* Output a debugging information about SCOPE when performing
1298 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1300 const char *desc
= cxx_scope_descriptor (scope
);
1301 if (scope
->this_entity
)
1302 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1303 scope
->this_entity
, (void *) scope
, line
);
1305 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1308 /* Return the estimated initial size of the hashtable of a NAMESPACE
1311 static inline size_t
1312 namespace_scope_ht_size (tree ns
)
1314 tree name
= DECL_NAME (ns
);
1316 return name
== std_identifier
1317 ? NAMESPACE_STD_HT_SIZE
1318 : (name
== global_scope_name
1319 ? GLOBAL_SCOPE_HT_SIZE
1320 : NAMESPACE_ORDINARY_HT_SIZE
);
1323 /* A chain of binding_level structures awaiting reuse. */
1325 static GTY((deletable
)) struct cp_binding_level
*free_binding_level
;
1327 /* Insert SCOPE as the innermost binding level. */
1330 push_binding_level (struct cp_binding_level
*scope
)
1332 /* Add it to the front of currently active scopes stack. */
1333 scope
->level_chain
= current_binding_level
;
1334 current_binding_level
= scope
;
1335 keep_next_level_flag
= false;
1337 if (ENABLE_SCOPE_CHECKING
)
1339 scope
->binding_depth
= binding_depth
;
1340 indent (binding_depth
);
1341 cxx_scope_debug (scope
, input_line
, "push");
1347 /* Create a new KIND scope and make it the top of the active scopes stack.
1348 ENTITY is the scope of the associated C++ entity (namespace, class,
1349 function, C++0x enumeration); it is NULL otherwise. */
1352 begin_scope (scope_kind kind
, tree entity
)
1356 /* Reuse or create a struct for this binding level. */
1357 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1359 scope
= free_binding_level
;
1360 memset (scope
, 0, sizeof (cxx_scope
));
1361 free_binding_level
= scope
->level_chain
;
1364 scope
= GGC_CNEW (cxx_scope
);
1366 scope
->this_entity
= entity
;
1367 scope
->more_cleanups_ok
= true;
1374 case sk_template_spec
:
1375 scope
->explicit_spec_p
= true;
1376 kind
= sk_template_parms
;
1378 case sk_template_parms
:
1384 case sk_scoped_enum
:
1385 case sk_function_parms
:
1387 scope
->keep
= keep_next_level_flag
;
1391 NAMESPACE_LEVEL (entity
) = scope
;
1392 scope
->static_decls
=
1393 VEC_alloc (tree
, gc
,
1394 DECL_NAME (entity
) == std_identifier
1395 || DECL_NAME (entity
) == global_scope_name
1400 /* Should not happen. */
1406 push_binding_level (scope
);
1411 /* We're about to leave current scope. Pop the top of the stack of
1412 currently active scopes. Return the enclosing scope, now active. */
1417 cxx_scope
*scope
= current_binding_level
;
1419 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1420 current_binding_level
= class_binding_level
;
1422 /* We cannot leave a scope, if there are none left. */
1423 if (NAMESPACE_LEVEL (global_namespace
))
1424 gcc_assert (!global_scope_p (scope
));
1426 if (ENABLE_SCOPE_CHECKING
)
1428 indent (--binding_depth
);
1429 cxx_scope_debug (scope
, input_line
, "leave");
1430 if (is_class_level
!= (scope
== class_binding_level
))
1432 indent (binding_depth
);
1433 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1438 /* Move one nesting level up. */
1439 current_binding_level
= scope
->level_chain
;
1441 /* Namespace-scopes are left most probably temporarily, not
1442 completely; they can be reopened later, e.g. in namespace-extension
1443 or any name binding activity that requires us to resume a
1444 namespace. For classes, we cache some binding levels. For other
1445 scopes, we just make the structure available for reuse. */
1446 if (scope
->kind
!= sk_namespace
1447 && scope
->kind
!= sk_class
)
1449 scope
->level_chain
= free_binding_level
;
1450 gcc_assert (!ENABLE_SCOPE_CHECKING
1451 || scope
->binding_depth
== binding_depth
);
1452 free_binding_level
= scope
;
1455 /* Find the innermost enclosing class scope, and reset
1456 CLASS_BINDING_LEVEL appropriately. */
1457 if (scope
->kind
== sk_class
)
1459 class_binding_level
= NULL
;
1460 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1461 if (scope
->kind
== sk_class
)
1463 class_binding_level
= scope
;
1468 return current_binding_level
;
1472 resume_scope (struct cp_binding_level
* b
)
1474 /* Resuming binding levels is meant only for namespaces,
1475 and those cannot nest into classes. */
1476 gcc_assert (!class_binding_level
);
1477 /* Also, resuming a non-directly nested namespace is a no-no. */
1478 gcc_assert (b
->level_chain
== current_binding_level
);
1479 current_binding_level
= b
;
1480 if (ENABLE_SCOPE_CHECKING
)
1482 b
->binding_depth
= binding_depth
;
1483 indent (binding_depth
);
1484 cxx_scope_debug (b
, input_line
, "resume");
1490 /* Return the innermost binding level that is not for a class scope. */
1493 innermost_nonclass_level (void)
1497 b
= current_binding_level
;
1498 while (b
->kind
== sk_class
)
1504 /* We're defining an object of type TYPE. If it needs a cleanup, but
1505 we're not allowed to add any more objects with cleanups to the current
1506 scope, create a new binding level. */
1509 maybe_push_cleanup_level (tree type
)
1511 if (type
!= error_mark_node
1512 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1513 && current_binding_level
->more_cleanups_ok
== 0)
1515 begin_scope (sk_cleanup
, NULL
);
1516 current_binding_level
->statement_list
= push_stmt_list ();
1520 /* Nonzero if we are currently in the global binding level. */
1523 global_bindings_p (void)
1525 return global_scope_p (current_binding_level
);
1528 /* True if we are currently in a toplevel binding level. This
1529 means either the global binding level or a namespace in a toplevel
1530 binding level. Since there are no non-toplevel namespace levels,
1531 this really means any namespace or template parameter level. We
1532 also include a class whose context is toplevel. */
1535 toplevel_bindings_p (void)
1537 struct cp_binding_level
*b
= innermost_nonclass_level ();
1539 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1542 /* True if this is a namespace scope, or if we are defining a class
1543 which is itself at namespace scope, or whose enclosing class is
1544 such a class, etc. */
1547 namespace_bindings_p (void)
1549 struct cp_binding_level
*b
= innermost_nonclass_level ();
1551 return b
->kind
== sk_namespace
;
1554 /* True if the current level needs to have a BLOCK made. */
1559 return (current_binding_level
->blocks
!= NULL_TREE
1560 || current_binding_level
->keep
1561 || current_binding_level
->kind
== sk_cleanup
1562 || current_binding_level
->names
!= NULL_TREE
1563 || current_binding_level
->using_directives
);
1566 /* Returns the kind of the innermost scope. */
1569 innermost_scope_kind (void)
1571 return current_binding_level
->kind
;
1574 /* Returns true if this scope was created to store template parameters. */
1577 template_parm_scope_p (void)
1579 return innermost_scope_kind () == sk_template_parms
;
1582 /* If KEEP is true, make a BLOCK node for the next binding level,
1583 unconditionally. Otherwise, use the normal logic to decide whether
1584 or not to create a BLOCK. */
1587 keep_next_level (bool keep
)
1589 keep_next_level_flag
= keep
;
1592 /* Return the list of declarations of the current level.
1593 Note that this list is in reverse order unless/until
1594 you nreverse it; and when you do nreverse it, you must
1595 store the result back using `storedecls' or you will lose. */
1600 return current_binding_level
->names
;
1603 /* For debugging. */
1604 static int no_print_functions
= 0;
1605 static int no_print_builtins
= 0;
1608 print_binding_level (struct cp_binding_level
* lvl
)
1612 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1613 if (lvl
->more_cleanups_ok
)
1614 fprintf (stderr
, " more-cleanups-ok");
1615 if (lvl
->have_cleanups
)
1616 fprintf (stderr
, " have-cleanups");
1617 fprintf (stderr
, "\n");
1620 fprintf (stderr
, " names:\t");
1621 /* We can probably fit 3 names to a line? */
1622 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1624 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1626 if (no_print_builtins
1627 && (TREE_CODE (t
) == TYPE_DECL
)
1628 && DECL_IS_BUILTIN (t
))
1631 /* Function decls tend to have longer names. */
1632 if (TREE_CODE (t
) == FUNCTION_DECL
)
1639 fprintf (stderr
, "\n\t");
1642 print_node_brief (stderr
, "", t
, 0);
1643 if (t
== error_mark_node
)
1647 fprintf (stderr
, "\n");
1649 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1652 cp_class_binding
*b
;
1653 fprintf (stderr
, " class-shadowed:");
1655 VEC_iterate(cp_class_binding
, lvl
->class_shadowed
, i
, b
);
1657 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1658 fprintf (stderr
, "\n");
1660 if (lvl
->type_shadowed
)
1662 fprintf (stderr
, " type-shadowed:");
1663 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1665 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1667 fprintf (stderr
, "\n");
1672 print_other_binding_stack (struct cp_binding_level
*stack
)
1674 struct cp_binding_level
*level
;
1675 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1677 fprintf (stderr
, "binding level %p\n", (void *) level
);
1678 print_binding_level (level
);
1683 print_binding_stack (void)
1685 struct cp_binding_level
*b
;
1686 fprintf (stderr
, "current_binding_level=%p\n"
1687 "class_binding_level=%p\n"
1688 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1689 (void *) current_binding_level
, (void *) class_binding_level
,
1690 (void *) NAMESPACE_LEVEL (global_namespace
));
1691 if (class_binding_level
)
1693 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1694 if (b
== current_binding_level
)
1697 b
= class_binding_level
;
1699 b
= current_binding_level
;
1702 b
= current_binding_level
;
1703 print_other_binding_stack (b
);
1704 fprintf (stderr
, "global:\n");
1705 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1708 /* Return the type associated with id. */
1711 identifier_type_value (tree id
)
1713 timevar_push (TV_NAME_LOOKUP
);
1714 /* There is no type with that name, anywhere. */
1715 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1717 /* This is not the type marker, but the real thing. */
1718 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1719 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, REAL_IDENTIFIER_TYPE_VALUE (id
));
1720 /* Have to search for it. It must be on the global level, now.
1721 Ask lookup_name not to return non-types. */
1722 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, TREE_TYPE (id
));
1725 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1728 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1729 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1732 identifier_global_value (tree t
)
1734 return IDENTIFIER_GLOBAL_VALUE (t
);
1737 /* Push a definition of struct, union or enum tag named ID. into
1738 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1739 the tag ID is not already defined. */
1742 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1746 if (b
->kind
!= sk_namespace
)
1748 /* Shadow the marker, not the real thing, so that the marker
1749 gets restored later. */
1750 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1752 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1753 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1754 TREE_TYPE (b
->type_shadowed
) = type
;
1758 cxx_binding
*binding
=
1759 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1762 supplement_binding (binding
, decl
);
1764 binding
->value
= decl
;
1766 /* Store marker instead of real type. */
1767 type
= global_type_node
;
1769 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1772 /* As set_identifier_type_value_with_scope, but using
1773 current_binding_level. */
1776 set_identifier_type_value (tree id
, tree decl
)
1778 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1781 /* Return the name for the constructor (or destructor) for the
1782 specified class TYPE. When given a template, this routine doesn't
1783 lose the specialization. */
1786 constructor_name_full (tree type
)
1788 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1791 /* Return the name for the constructor (or destructor) for the
1792 specified class. When given a template, return the plain
1793 unspecialized name. */
1796 constructor_name (tree type
)
1799 name
= constructor_name_full (type
);
1800 if (IDENTIFIER_TEMPLATE (name
))
1801 name
= IDENTIFIER_TEMPLATE (name
);
1805 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1806 which must be a class type. */
1809 constructor_name_p (tree name
, tree type
)
1813 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
1818 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1821 ctor_name
= constructor_name_full (type
);
1822 if (name
== ctor_name
)
1824 if (IDENTIFIER_TEMPLATE (ctor_name
)
1825 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1830 /* Counter used to create anonymous type names. */
1832 static GTY(()) int anon_cnt
;
1834 /* Return an IDENTIFIER which can be used as a name for
1835 anonymous structs and unions. */
1838 make_anon_name (void)
1842 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1843 return get_identifier (buf
);
1846 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1848 static inline cxx_binding
*
1849 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1851 timevar_push (TV_NAME_LOOKUP
);
1853 for (; binding
!= NULL
; binding
= binding
->previous
)
1854 if (binding
->scope
== scope
)
1855 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
);
1857 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, (cxx_binding
*)0);
1860 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1862 static inline cxx_binding
*
1863 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1865 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1868 /* Fold-in case where NAME is used only once. */
1869 if (scope
== b
->scope
&& b
->previous
== NULL
)
1871 return find_binding (scope
, b
);
1876 /* Always returns a binding for name in scope. If no binding is
1877 found, make a new one. */
1879 static cxx_binding
*
1880 binding_for_name (cxx_scope
*scope
, tree name
)
1882 cxx_binding
*result
;
1884 result
= cxx_scope_find_binding_for_name (scope
, name
);
1887 /* Not found, make a new one. */
1888 result
= cxx_binding_make (NULL
, NULL
);
1889 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1890 result
->scope
= scope
;
1891 result
->is_local
= false;
1892 result
->value_is_inherited
= false;
1893 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1897 /* Walk through the bindings associated to the name of FUNCTION,
1898 and return the first binding that declares a function with a
1899 "C" linkage specification, a.k.a 'extern "C"'.
1900 This function looks for the binding, regardless of which scope it
1901 has been defined in. It basically looks in all the known scopes.
1902 Note that this function does not lookup for bindings of builtin functions
1903 or for functions declared in system headers. */
1905 lookup_extern_c_fun_binding_in_all_ns (tree function
)
1910 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
1912 name
= DECL_NAME (function
);
1913 gcc_assert (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
);
1915 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1917 iter
= iter
->previous
)
1920 && TREE_CODE (iter
->value
) == FUNCTION_DECL
1921 && DECL_EXTERN_C_P (iter
->value
)
1922 && !DECL_ARTIFICIAL (iter
->value
))
1930 /* Insert another USING_DECL into the current binding level, returning
1931 this declaration. If this is a redeclaration, do nothing, and
1932 return NULL_TREE if this not in namespace scope (in namespace
1933 scope, a using decl might extend any previous bindings). */
1936 push_using_decl (tree scope
, tree name
)
1940 timevar_push (TV_NAME_LOOKUP
);
1941 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
1942 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1943 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
1944 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
1947 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
1948 namespace_bindings_p () ? decl
: NULL_TREE
);
1949 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
1950 USING_DECL_SCOPE (decl
) = scope
;
1951 TREE_CHAIN (decl
) = current_binding_level
->usings
;
1952 current_binding_level
->usings
= decl
;
1953 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1956 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1957 caller to set DECL_CONTEXT properly. */
1960 pushdecl_with_scope (tree x
, cxx_scope
*level
, bool is_friend
)
1962 struct cp_binding_level
*b
;
1963 tree function_decl
= current_function_decl
;
1965 timevar_push (TV_NAME_LOOKUP
);
1966 current_function_decl
= NULL_TREE
;
1967 if (level
->kind
== sk_class
)
1969 b
= class_binding_level
;
1970 class_binding_level
= level
;
1971 pushdecl_class_level (x
);
1972 class_binding_level
= b
;
1976 b
= current_binding_level
;
1977 current_binding_level
= level
;
1978 x
= pushdecl_maybe_friend (x
, is_friend
);
1979 current_binding_level
= b
;
1981 current_function_decl
= function_decl
;
1982 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1985 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1986 other definitions already in place. We get around this by making
1987 the value of the identifier point to a list of all the things that
1988 want to be referenced by that name. It is then up to the users of
1989 that name to decide what to do with that list.
1991 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1992 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1994 FLAGS is a bitwise-or of the following values:
1995 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1997 PUSH_USING: DECL is being pushed as the result of a using
2000 IS_FRIEND is true if this is a friend declaration.
2002 The value returned may be a previous declaration if we guessed wrong
2003 about what language DECL should belong to (C or C++). Otherwise,
2004 it's always DECL (and never something that's not a _DECL). */
2007 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2009 tree name
= DECL_NAME (decl
);
2012 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2014 timevar_push (TV_NAME_LOOKUP
);
2016 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2018 old
= lookup_name_innermost_nonclass_level (name
);
2022 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2024 tree t
= TREE_TYPE (old
);
2025 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2026 && (! DECL_IN_SYSTEM_HEADER (decl
)
2027 || ! DECL_IN_SYSTEM_HEADER (old
)))
2028 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2031 else if (is_overloaded_fn (old
))
2035 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2037 tree fn
= OVL_CURRENT (tmp
);
2040 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2041 && !(flags
& PUSH_USING
)
2042 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2043 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
2044 && ! decls_match (fn
, decl
))
2045 error ("%q#D conflicts with previous using declaration %q#D",
2048 dup
= duplicate_decls (decl
, fn
, is_friend
);
2049 /* If DECL was a redeclaration of FN -- even an invalid
2050 one -- pass that information along to our caller. */
2051 if (dup
== fn
|| dup
== error_mark_node
)
2052 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, dup
);
2055 /* We don't overload implicit built-ins. duplicate_decls()
2056 may fail to merge the decls if the new decl is e.g. a
2057 template function. */
2058 if (TREE_CODE (old
) == FUNCTION_DECL
2059 && DECL_ANTICIPATED (old
)
2060 && !DECL_HIDDEN_FRIEND_P (old
))
2063 else if (old
== error_mark_node
)
2064 /* Ignore the undefined symbol marker. */
2068 error ("previous non-function declaration %q+#D", old
);
2069 error ("conflicts with function declaration %q#D", decl
);
2070 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2074 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2075 /* If it's a using declaration, we always need to build an OVERLOAD,
2076 because it's the only way to remember that the declaration comes
2077 from 'using', and have the lookup behave correctly. */
2078 || (flags
& PUSH_USING
))
2080 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2081 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2083 new_binding
= ovl_cons (decl
, old
);
2084 if (flags
& PUSH_USING
)
2085 OVL_USED (new_binding
) = 1;
2088 /* NAME is not ambiguous. */
2092 set_namespace_binding (name
, current_namespace
, new_binding
);
2095 /* We only create an OVERLOAD if there was a previous binding at
2096 this level, or if decl is a template. In the former case, we
2097 need to remove the old binding and replace it with the new
2098 binding. We must also run through the NAMES on the binding
2099 level where the name was bound to update the chain. */
2101 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2105 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2107 d
= &TREE_CHAIN (*d
))
2109 || (TREE_CODE (*d
) == TREE_LIST
2110 && TREE_VALUE (*d
) == old
))
2112 if (TREE_CODE (*d
) == TREE_LIST
)
2113 /* Just replace the old binding with the new. */
2114 TREE_VALUE (*d
) = new_binding
;
2116 /* Build a TREE_LIST to wrap the OVERLOAD. */
2117 *d
= tree_cons (NULL_TREE
, new_binding
,
2120 /* And update the cxx_binding node. */
2121 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2122 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2125 /* We should always find a previous binding in this case. */
2129 /* Install the new binding. */
2130 push_local_binding (name
, new_binding
, flags
);
2133 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2136 /* Check a non-member using-declaration. Return the name and scope
2137 being used, and the USING_DECL, or NULL_TREE on failure. */
2140 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2142 /* [namespace.udecl]
2143 A using-declaration for a class member shall be a
2144 member-declaration. */
2147 error ("%qT is not a namespace", scope
);
2150 else if (scope
== error_mark_node
)
2153 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2156 A using-declaration shall not name a template-id. */
2157 error ("a using-declaration cannot specify a template-id. "
2158 "Try %<using %D%>", name
);
2162 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2164 error ("namespace %qD not allowed in using-declaration", decl
);
2168 if (TREE_CODE (decl
) == SCOPE_REF
)
2170 /* It's a nested name with template parameter dependent scope.
2171 This can only be using-declaration for class member. */
2172 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2176 if (is_overloaded_fn (decl
))
2177 decl
= get_first_fn (decl
);
2179 gcc_assert (DECL_P (decl
));
2181 /* Make a USING_DECL. */
2182 return push_using_decl (scope
, name
);
2185 /* Process local and global using-declarations. */
2188 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2189 tree
*newval
, tree
*newtype
)
2191 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2193 *newval
= *newtype
= NULL_TREE
;
2194 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2198 if (!decls
.value
&& !decls
.type
)
2200 error ("%qD not declared", name
);
2204 /* Shift the old and new bindings around so we're comparing class and
2205 enumeration names to each other. */
2206 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2212 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2214 decls
.type
= decls
.value
;
2215 decls
.value
= NULL_TREE
;
2218 /* It is impossible to overload a built-in function; any explicit
2219 declaration eliminates the built-in declaration. So, if OLDVAL
2220 is a built-in, then we can just pretend it isn't there. */
2222 && TREE_CODE (oldval
) == FUNCTION_DECL
2223 && DECL_ANTICIPATED (oldval
)
2224 && !DECL_HIDDEN_FRIEND_P (oldval
))
2229 /* Check for using functions. */
2230 if (is_overloaded_fn (decls
.value
))
2234 if (oldval
&& !is_overloaded_fn (oldval
))
2236 error ("%qD is already declared in this scope", name
);
2241 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2243 tree new_fn
= OVL_CURRENT (tmp
);
2245 /* [namespace.udecl]
2247 If a function declaration in namespace scope or block
2248 scope has the same name and the same parameter types as a
2249 function introduced by a using declaration the program is
2251 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2253 tree old_fn
= OVL_CURRENT (tmp1
);
2255 if (new_fn
== old_fn
)
2256 /* The function already exists in the current namespace. */
2258 else if (OVL_USED (tmp1
))
2259 continue; /* this is a using decl */
2260 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2261 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2263 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2264 || DECL_HIDDEN_FRIEND_P (old_fn
));
2266 /* There was already a non-using declaration in
2267 this scope with the same parameter types. If both
2268 are the same extern "C" functions, that's ok. */
2269 if (decls_match (new_fn
, old_fn
))
2273 error ("%qD is already declared in this scope", name
);
2279 /* If we broke out of the loop, there's no reason to add
2280 this function to the using declarations for this
2285 /* If we are adding to an existing OVERLOAD, then we no
2286 longer know the type of the set of functions. */
2287 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2288 TREE_TYPE (*newval
) = unknown_type_node
;
2289 /* Add this new function to the set. */
2290 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2291 /* If there is only one function, then we use its type. (A
2292 using-declaration naming a single function can be used in
2293 contexts where overload resolution cannot be
2295 if (TREE_CODE (*newval
) != OVERLOAD
)
2297 *newval
= ovl_cons (*newval
, NULL_TREE
);
2298 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2300 OVL_USED (*newval
) = 1;
2305 *newval
= decls
.value
;
2306 if (oldval
&& !decls_match (*newval
, oldval
))
2307 error ("%qD is already declared in this scope", name
);
2313 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2315 error ("reference to %qD is ambiguous", name
);
2316 print_candidates (decls
.type
);
2320 *newtype
= decls
.type
;
2321 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2322 error ("%qD is already declared in this scope", name
);
2325 /* If *newval is empty, shift any class or enumeration name down. */
2329 *newtype
= NULL_TREE
;
2333 /* Process a using-declaration at function scope. */
2336 do_local_using_decl (tree decl
, tree scope
, tree name
)
2338 tree oldval
, oldtype
, newval
, newtype
;
2339 tree orig_decl
= decl
;
2341 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2342 if (decl
== NULL_TREE
)
2345 if (building_stmt_tree ()
2346 && at_function_scope_p ())
2347 add_decl_expr (decl
);
2349 oldval
= lookup_name_innermost_nonclass_level (name
);
2350 oldtype
= lookup_type_current_level (name
);
2352 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2356 if (is_overloaded_fn (newval
))
2360 /* We only need to push declarations for those functions
2361 that were not already bound in the current level.
2362 The old value might be NULL_TREE, it might be a single
2363 function, or an OVERLOAD. */
2364 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2365 term
= OVL_FUNCTION (oldval
);
2368 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2370 push_overloaded_decl (OVL_CURRENT (fn
),
2371 PUSH_LOCAL
| PUSH_USING
,
2375 push_local_binding (name
, newval
, PUSH_USING
);
2379 push_local_binding (name
, newtype
, PUSH_USING
);
2380 set_identifier_type_value (name
, newtype
);
2383 /* Emit debug info. */
2384 if (!processing_template_decl
)
2385 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2388 /* Returns true if ROOT (a namespace, class, or function) encloses
2389 CHILD. CHILD may be either a class type or a namespace. */
2392 is_ancestor (tree root
, tree child
)
2394 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2395 || TREE_CODE (root
) == FUNCTION_DECL
2396 || CLASS_TYPE_P (root
)));
2397 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2398 || CLASS_TYPE_P (child
)));
2400 /* The global namespace encloses everything. */
2401 if (root
== global_namespace
)
2406 /* If we've run out of scopes, stop. */
2409 /* If we've reached the ROOT, it encloses CHILD. */
2412 /* Go out one level. */
2414 child
= TYPE_NAME (child
);
2415 child
= DECL_CONTEXT (child
);
2419 /* Enter the class or namespace scope indicated by T suitable for name
2420 lookup. T can be arbitrary scope, not necessary nested inside the
2421 current scope. Returns a non-null scope to pop iff pop_scope
2422 should be called later to exit this scope. */
2427 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2428 push_decl_namespace (t
);
2429 else if (CLASS_TYPE_P (t
))
2431 if (!at_class_scope_p ()
2432 || !same_type_p (current_class_type
, t
))
2433 push_nested_class (t
);
2435 /* T is the same as the current scope. There is therefore no
2436 need to re-enter the scope. Since we are not actually
2437 pushing a new scope, our caller should not call
2445 /* Leave scope pushed by push_scope. */
2450 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2451 pop_decl_namespace ();
2452 else if CLASS_TYPE_P (t
)
2453 pop_nested_class ();
2456 /* Subroutine of push_inner_scope. */
2459 push_inner_scope_r (tree outer
, tree inner
)
2464 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2467 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2469 push_inner_scope_r (outer
, prev
);
2470 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2472 struct cp_binding_level
*save_template_parm
= 0;
2473 /* Temporary take out template parameter scopes. They are saved
2474 in reversed order in save_template_parm. */
2475 while (current_binding_level
->kind
== sk_template_parms
)
2477 struct cp_binding_level
*b
= current_binding_level
;
2478 current_binding_level
= b
->level_chain
;
2479 b
->level_chain
= save_template_parm
;
2480 save_template_parm
= b
;
2483 resume_scope (NAMESPACE_LEVEL (inner
));
2484 current_namespace
= inner
;
2486 /* Restore template parameter scopes. */
2487 while (save_template_parm
)
2489 struct cp_binding_level
*b
= save_template_parm
;
2490 save_template_parm
= b
->level_chain
;
2491 b
->level_chain
= current_binding_level
;
2492 current_binding_level
= b
;
2499 /* Enter the scope INNER from current scope. INNER must be a scope
2500 nested inside current scope. This works with both name lookup and
2501 pushing name into scope. In case a template parameter scope is present,
2502 namespace is pushed under the template parameter scope according to
2503 name lookup rule in 14.6.1/6.
2505 Return the former current scope suitable for pop_inner_scope. */
2508 push_inner_scope (tree inner
)
2510 tree outer
= current_scope ();
2512 outer
= current_namespace
;
2514 push_inner_scope_r (outer
, inner
);
2518 /* Exit the current scope INNER back to scope OUTER. */
2521 pop_inner_scope (tree outer
, tree inner
)
2524 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2527 while (outer
!= inner
)
2529 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2531 struct cp_binding_level
*save_template_parm
= 0;
2532 /* Temporary take out template parameter scopes. They are saved
2533 in reversed order in save_template_parm. */
2534 while (current_binding_level
->kind
== sk_template_parms
)
2536 struct cp_binding_level
*b
= current_binding_level
;
2537 current_binding_level
= b
->level_chain
;
2538 b
->level_chain
= save_template_parm
;
2539 save_template_parm
= b
;
2544 /* Restore template parameter scopes. */
2545 while (save_template_parm
)
2547 struct cp_binding_level
*b
= save_template_parm
;
2548 save_template_parm
= b
->level_chain
;
2549 b
->level_chain
= current_binding_level
;
2550 current_binding_level
= b
;
2556 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2560 /* Do a pushlevel for class declarations. */
2563 pushlevel_class (void)
2565 if (ENABLE_SCOPE_CHECKING
)
2568 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2571 /* ...and a poplevel for class declarations. */
2574 poplevel_class (void)
2576 struct cp_binding_level
*level
= class_binding_level
;
2577 cp_class_binding
*cb
;
2581 timevar_push (TV_NAME_LOOKUP
);
2582 gcc_assert (level
!= 0);
2584 /* If we're leaving a toplevel class, cache its binding level. */
2585 if (current_class_depth
== 1)
2586 previous_class_level
= level
;
2587 for (shadowed
= level
->type_shadowed
;
2589 shadowed
= TREE_CHAIN (shadowed
))
2590 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2592 /* Remove the bindings for all of the class-level declarations. */
2593 if (level
->class_shadowed
)
2596 VEC_iterate (cp_class_binding
, level
->class_shadowed
, i
, cb
);
2598 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
.previous
;
2599 ggc_free (level
->class_shadowed
);
2600 level
->class_shadowed
= NULL
;
2603 /* Now, pop out of the binding level which we created up in the
2604 `pushlevel_class' routine. */
2605 if (ENABLE_SCOPE_CHECKING
)
2609 timevar_pop (TV_NAME_LOOKUP
);
2612 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2613 appropriate. DECL is the value to which a name has just been
2614 bound. CLASS_TYPE is the class in which the lookup occurred. */
2617 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2620 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2624 if (TREE_CODE (decl
) == OVERLOAD
)
2625 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2628 gcc_assert (DECL_P (decl
));
2629 context
= context_for_name_lookup (decl
);
2632 if (is_properly_derived_from (class_type
, context
))
2633 INHERITED_VALUE_BINDING_P (binding
) = 1;
2635 INHERITED_VALUE_BINDING_P (binding
) = 0;
2637 else if (binding
->value
== decl
)
2638 /* We only encounter a TREE_LIST when there is an ambiguity in the
2639 base classes. Such an ambiguity can be overridden by a
2640 definition in this class. */
2641 INHERITED_VALUE_BINDING_P (binding
) = 1;
2643 INHERITED_VALUE_BINDING_P (binding
) = 0;
2646 /* Make the declaration of X appear in CLASS scope. */
2649 pushdecl_class_level (tree x
)
2652 bool is_valid
= true;
2654 timevar_push (TV_NAME_LOOKUP
);
2655 /* Get the name of X. */
2656 if (TREE_CODE (x
) == OVERLOAD
)
2657 name
= DECL_NAME (get_first_fn (x
));
2659 name
= DECL_NAME (x
);
2663 is_valid
= push_class_level_binding (name
, x
);
2664 if (TREE_CODE (x
) == TYPE_DECL
)
2665 set_identifier_type_value (name
, x
);
2667 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2669 /* If X is an anonymous aggregate, all of its members are
2670 treated as if they were members of the class containing the
2671 aggregate, for naming purposes. */
2674 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= TREE_CHAIN (f
))
2676 location_t save_location
= input_location
;
2677 input_location
= DECL_SOURCE_LOCATION (f
);
2678 if (!pushdecl_class_level (f
))
2680 input_location
= save_location
;
2683 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, is_valid
);
2686 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2687 scope. If the value returned is non-NULL, and the PREVIOUS field
2688 is not set, callers must set the PREVIOUS field explicitly. */
2690 static cxx_binding
*
2691 get_class_binding (tree name
, cxx_scope
*scope
)
2696 cxx_binding
*binding
;
2698 class_type
= scope
->this_entity
;
2700 /* Get the type binding. */
2701 type_binding
= lookup_member (class_type
, name
,
2702 /*protect=*/2, /*want_type=*/true);
2703 /* Get the value binding. */
2704 value_binding
= lookup_member (class_type
, name
,
2705 /*protect=*/2, /*want_type=*/false);
2708 && (TREE_CODE (value_binding
) == TYPE_DECL
2709 || DECL_CLASS_TEMPLATE_P (value_binding
)
2710 || (TREE_CODE (value_binding
) == TREE_LIST
2711 && TREE_TYPE (value_binding
) == error_mark_node
2712 && (TREE_CODE (TREE_VALUE (value_binding
))
2714 /* We found a type binding, even when looking for a non-type
2715 binding. This means that we already processed this binding
2718 else if (value_binding
)
2720 if (TREE_CODE (value_binding
) == TREE_LIST
2721 && TREE_TYPE (value_binding
) == error_mark_node
)
2722 /* NAME is ambiguous. */
2724 else if (BASELINK_P (value_binding
))
2725 /* NAME is some overloaded functions. */
2726 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2729 /* If we found either a type binding or a value binding, create a
2730 new binding object. */
2731 if (type_binding
|| value_binding
)
2733 binding
= new_class_binding (name
,
2737 /* This is a class-scope binding, not a block-scope binding. */
2738 LOCAL_BINDING_P (binding
) = 0;
2739 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2747 /* Make the declaration(s) of X appear in CLASS scope under the name
2748 NAME. Returns true if the binding is valid. */
2751 push_class_level_binding (tree name
, tree x
)
2753 cxx_binding
*binding
;
2757 timevar_push (TV_NAME_LOOKUP
);
2758 /* The class_binding_level will be NULL if x is a template
2759 parameter name in a member template. */
2760 if (!class_binding_level
)
2761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2763 if (name
== error_mark_node
)
2764 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2766 /* Check for invalid member names. */
2767 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2768 /* We could have been passed a tree list if this is an ambiguous
2769 declaration. If so, pull the declaration out because
2770 check_template_shadow will not handle a TREE_LIST. */
2771 if (TREE_CODE (decl
) == TREE_LIST
2772 && TREE_TYPE (decl
) == error_mark_node
)
2773 decl
= TREE_VALUE (decl
);
2775 if (!check_template_shadow (decl
))
2776 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2780 If T is the name of a class, then each of the following shall
2781 have a name different from T:
2783 -- every static data member of class T;
2785 -- every member of class T that is itself a type;
2787 -- every enumerator of every member of class T that is an
2790 -- every member of every anonymous union that is a member of
2793 (Non-static data members were also forbidden to have the same
2794 name as T until TC1.) */
2795 if ((TREE_CODE (x
) == VAR_DECL
2796 || TREE_CODE (x
) == CONST_DECL
2797 || (TREE_CODE (x
) == TYPE_DECL
2798 && !DECL_SELF_REFERENCE_P (x
))
2799 /* A data member of an anonymous union. */
2800 || (TREE_CODE (x
) == FIELD_DECL
2801 && DECL_CONTEXT (x
) != current_class_type
))
2802 && DECL_NAME (x
) == constructor_name (current_class_type
))
2804 tree scope
= context_for_name_lookup (x
);
2805 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
2807 error ("%qD has the same name as the class in which it is "
2810 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2814 /* Get the current binding for NAME in this class, if any. */
2815 binding
= IDENTIFIER_BINDING (name
);
2816 if (!binding
|| binding
->scope
!= class_binding_level
)
2818 binding
= get_class_binding (name
, class_binding_level
);
2819 /* If a new binding was created, put it at the front of the
2820 IDENTIFIER_BINDING list. */
2823 binding
->previous
= IDENTIFIER_BINDING (name
);
2824 IDENTIFIER_BINDING (name
) = binding
;
2828 /* If there is already a binding, then we may need to update the
2830 if (binding
&& binding
->value
)
2832 tree bval
= binding
->value
;
2833 tree old_decl
= NULL_TREE
;
2835 if (INHERITED_VALUE_BINDING_P (binding
))
2837 /* If the old binding was from a base class, and was for a
2838 tag name, slide it over to make room for the new binding.
2839 The old binding is still visible if explicitly qualified
2840 with a class-key. */
2841 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2842 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2844 old_decl
= binding
->type
;
2845 binding
->type
= bval
;
2846 binding
->value
= NULL_TREE
;
2847 INHERITED_VALUE_BINDING_P (binding
) = 0;
2852 /* Any inherited type declaration is hidden by the type
2853 declaration in the derived class. */
2854 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
))
2855 binding
->type
= NULL_TREE
;
2858 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2860 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2861 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2862 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
2864 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
2865 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2867 if (old_decl
&& binding
->scope
== class_binding_level
)
2870 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2871 here. This function is only used to register bindings
2872 from with the class definition itself. */
2873 INHERITED_VALUE_BINDING_P (binding
) = 0;
2874 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2878 /* Note that we declared this value so that we can issue an error if
2879 this is an invalid redeclaration of a name already used for some
2881 note_name_declared_in_class (name
, decl
);
2883 /* If we didn't replace an existing binding, put the binding on the
2884 stack of bindings for the identifier, and update the shadowed
2886 if (binding
&& binding
->scope
== class_binding_level
)
2887 /* Supplement the existing binding. */
2888 ok
= supplement_binding (binding
, decl
);
2891 /* Create a new binding. */
2892 push_binding (name
, decl
, class_binding_level
);
2896 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
2899 /* Process "using SCOPE::NAME" in a class scope. Return the
2900 USING_DECL created. */
2903 do_class_using_decl (tree scope
, tree name
)
2905 /* The USING_DECL returned by this function. */
2907 /* The declaration (or declarations) name by this using
2908 declaration. NULL if we are in a template and cannot figure out
2909 what has been named. */
2911 /* True if SCOPE is a dependent type. */
2912 bool scope_dependent_p
;
2913 /* True if SCOPE::NAME is dependent. */
2914 bool name_dependent_p
;
2915 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2916 bool bases_dependent_p
;
2921 if (name
== error_mark_node
)
2924 if (!scope
|| !TYPE_P (scope
))
2926 error ("using-declaration for non-member at class scope");
2930 /* Make sure the name is not invalid */
2931 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2933 error ("%<%T::%D%> names destructor", scope
, name
);
2936 if (MAYBE_CLASS_TYPE_P (scope
) && constructor_name_p (name
, scope
))
2938 error ("%<%T::%D%> names constructor", scope
, name
);
2941 if (constructor_name_p (name
, current_class_type
))
2943 error ("%<%T::%D%> names constructor in %qT",
2944 scope
, name
, current_class_type
);
2948 scope_dependent_p
= dependent_type_p (scope
);
2949 name_dependent_p
= (scope_dependent_p
2950 || (IDENTIFIER_TYPENAME_P (name
)
2951 && dependent_type_p (TREE_TYPE (name
))));
2953 bases_dependent_p
= false;
2954 if (processing_template_decl
)
2955 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
2956 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
2958 if (dependent_type_p (TREE_TYPE (base_binfo
)))
2960 bases_dependent_p
= true;
2966 /* From [namespace.udecl]:
2968 A using-declaration used as a member-declaration shall refer to a
2969 member of a base class of the class being defined.
2971 In general, we cannot check this constraint in a template because
2972 we do not know the entire set of base classes of the current
2973 class type. However, if all of the base classes are
2974 non-dependent, then we can avoid delaying the check until
2976 if (!scope_dependent_p
)
2979 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
2980 if (b_kind
< bk_proper_base
)
2982 if (!bases_dependent_p
)
2984 error_not_base_type (scope
, current_class_type
);
2988 else if (!name_dependent_p
)
2990 decl
= lookup_member (binfo
, name
, 0, false);
2993 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
2997 /* The binfo from which the functions came does not matter. */
2998 if (BASELINK_P (decl
))
2999 decl
= BASELINK_FUNCTIONS (decl
);
3003 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3004 USING_DECL_DECLS (value
) = decl
;
3005 USING_DECL_SCOPE (value
) = scope
;
3006 DECL_DEPENDENT_P (value
) = !decl
;
3012 /* Return the binding value for name in scope. */
3015 namespace_binding (tree name
, tree scope
)
3017 cxx_binding
*binding
;
3020 scope
= global_namespace
;
3022 /* Unnecessary for the global namespace because it can't be an alias. */
3023 scope
= ORIGINAL_NAMESPACE (scope
);
3025 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3027 return binding
? binding
->value
: NULL_TREE
;
3030 /* Set the binding value for name in scope. */
3033 set_namespace_binding (tree name
, tree scope
, tree val
)
3037 timevar_push (TV_NAME_LOOKUP
);
3038 if (scope
== NULL_TREE
)
3039 scope
= global_namespace
;
3040 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3041 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3044 supplement_binding (b
, val
);
3045 timevar_pop (TV_NAME_LOOKUP
);
3048 /* Set the context of a declaration to scope. Complain if we are not
3052 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3056 /* Get rid of namespace aliases. */
3057 scope
= ORIGINAL_NAMESPACE (scope
);
3059 /* It is ok for friends to be qualified in parallel space. */
3060 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3061 error ("declaration of %qD not in a namespace surrounding %qD",
3063 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3065 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3066 if (scope
== current_namespace
)
3068 if (at_namespace_scope_p ())
3069 error ("explicit qualification in declaration of %qD",
3074 /* See whether this has been declared in the namespace. */
3075 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3076 if (old
== error_mark_node
)
3077 /* No old declaration at all. */
3079 if (!is_overloaded_fn (decl
))
3080 /* Don't compare non-function decls with decls_match here, since
3081 it can't check for the correct constness at this
3082 point. pushdecl will find those errors later. */
3084 /* Since decl is a function, old should contain a function decl. */
3085 if (!is_overloaded_fn (old
))
3087 fn
= OVL_CURRENT (old
);
3088 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (fn
)))
3090 /* A template can be explicitly specialized in any namespace. */
3091 if (processing_explicit_instantiation
)
3093 if (processing_template_decl
|| processing_specialization
)
3094 /* We have not yet called push_template_decl to turn a
3095 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3096 match. But, we'll check later, when we construct the
3099 /* Instantiations or specializations of templates may be declared as
3100 friends in any namespace. */
3101 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3103 if (is_overloaded_fn (old
))
3105 for (; old
; old
= OVL_NEXT (old
))
3106 if (decls_match (decl
, OVL_CURRENT (old
)))
3109 else if (decls_match (decl
, old
))
3112 error ("%qD should have been declared inside %qD", decl
, scope
);
3115 /* Return the namespace where the current declaration is declared. */
3118 current_decl_namespace (void)
3121 /* If we have been pushed into a different namespace, use it. */
3122 if (decl_namespace_list
)
3123 return TREE_PURPOSE (decl_namespace_list
);
3125 if (current_class_type
)
3126 result
= decl_namespace_context (current_class_type
);
3127 else if (current_function_decl
)
3128 result
= decl_namespace_context (current_function_decl
);
3130 result
= current_namespace
;
3134 /* Process any ATTRIBUTES on a namespace definition. Currently only
3135 attribute visibility is meaningful, which is a property of the syntactic
3136 block rather than the namespace as a whole, so we don't touch the
3137 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3140 handle_namespace_attrs (tree ns
, tree attributes
)
3143 bool saw_vis
= false;
3145 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3147 tree name
= TREE_PURPOSE (d
);
3148 tree args
= TREE_VALUE (d
);
3150 #ifdef HANDLE_PRAGMA_VISIBILITY
3151 if (is_attribute_p ("visibility", name
))
3153 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3154 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3156 warning (OPT_Wattributes
,
3157 "%qD attribute requires a single NTBS argument",
3162 if (!TREE_PUBLIC (ns
))
3163 warning (OPT_Wattributes
,
3164 "%qD attribute is meaningless since members of the "
3165 "anonymous namespace get local symbols", name
);
3167 push_visibility (TREE_STRING_POINTER (x
));
3173 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3182 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3183 select a name that is unique to this compilation unit. */
3186 push_namespace (tree name
)
3190 int implicit_use
= 0;
3193 timevar_push (TV_NAME_LOOKUP
);
3195 /* We should not get here if the global_namespace is not yet constructed
3196 nor if NAME designates the global namespace: The global scope is
3197 constructed elsewhere. */
3198 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3202 name
= get_anonymous_namespace_name();
3203 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3205 /* Reopening anonymous namespace. */
3211 /* Check whether this is an extended namespace definition. */
3212 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3213 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3216 if (DECL_NAMESPACE_ALIAS (d
))
3218 error ("namespace alias %qD not allowed here, assuming %qD",
3219 d
, DECL_NAMESPACE_ALIAS (d
));
3220 d
= DECL_NAMESPACE_ALIAS (d
);
3227 /* Make a new namespace, binding the name to it. */
3228 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3229 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3230 /* The name of this namespace is not visible to other translation
3231 units if it is an anonymous namespace or member thereof. */
3232 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3233 TREE_PUBLIC (d
) = 0;
3235 TREE_PUBLIC (d
) = 1;
3239 /* Clear DECL_NAME for the benefit of debugging back ends. */
3240 SET_DECL_ASSEMBLER_NAME (d
, name
);
3241 DECL_NAME (d
) = NULL_TREE
;
3243 begin_scope (sk_namespace
, d
);
3246 resume_scope (NAMESPACE_LEVEL (d
));
3249 do_using_directive (d
);
3250 /* Enter the name space. */
3251 current_namespace
= d
;
3253 timevar_pop (TV_NAME_LOOKUP
);
3256 /* Pop from the scope of the current namespace. */
3259 pop_namespace (void)
3261 gcc_assert (current_namespace
!= global_namespace
);
3262 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3263 /* The binding level is not popped, as it might be re-opened later. */
3267 /* Push into the scope of the namespace NS, even if it is deeply
3268 nested within another namespace. */
3271 push_nested_namespace (tree ns
)
3273 if (ns
== global_namespace
)
3274 push_to_top_level ();
3277 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3278 push_namespace (DECL_NAME (ns
));
3282 /* Pop back from the scope of the namespace NS, which was previously
3283 entered with push_nested_namespace. */
3286 pop_nested_namespace (tree ns
)
3288 timevar_push (TV_NAME_LOOKUP
);
3289 while (ns
!= global_namespace
)
3292 ns
= CP_DECL_CONTEXT (ns
);
3295 pop_from_top_level ();
3296 timevar_pop (TV_NAME_LOOKUP
);
3299 /* Temporarily set the namespace for the current declaration. */
3302 push_decl_namespace (tree decl
)
3304 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3305 decl
= decl_namespace_context (decl
);
3306 decl_namespace_list
= tree_cons (ORIGINAL_NAMESPACE (decl
),
3307 NULL_TREE
, decl_namespace_list
);
3310 /* [namespace.memdef]/2 */
3313 pop_decl_namespace (void)
3315 decl_namespace_list
= TREE_CHAIN (decl_namespace_list
);
3318 /* Return the namespace that is the common ancestor
3319 of two given namespaces. */
3322 namespace_ancestor (tree ns1
, tree ns2
)
3324 timevar_push (TV_NAME_LOOKUP
);
3325 if (is_ancestor (ns1
, ns2
))
3326 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ns1
);
3327 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
3328 namespace_ancestor (CP_DECL_CONTEXT (ns1
), ns2
));
3331 /* Process a namespace-alias declaration. */
3334 do_namespace_alias (tree alias
, tree name_space
)
3336 if (name_space
== error_mark_node
)
3339 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3341 name_space
= ORIGINAL_NAMESPACE (name_space
);
3343 /* Build the alias. */
3344 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3345 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3346 DECL_EXTERNAL (alias
) = 1;
3347 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3350 /* Emit debug info for namespace alias. */
3351 if (!building_stmt_tree ())
3352 (*debug_hooks
->global_decl
) (alias
);
3355 /* Like pushdecl, only it places X in the current namespace,
3359 pushdecl_namespace_level (tree x
, bool is_friend
)
3361 struct cp_binding_level
*b
= current_binding_level
;
3364 timevar_push (TV_NAME_LOOKUP
);
3365 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3367 /* Now, the type_shadowed stack may screw us. Munge it so it does
3369 if (TREE_CODE (t
) == TYPE_DECL
)
3371 tree name
= DECL_NAME (t
);
3373 tree
*ptr
= (tree
*)0;
3374 for (; !global_scope_p (b
); b
= b
->level_chain
)
3376 tree shadowed
= b
->type_shadowed
;
3377 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3378 if (TREE_PURPOSE (shadowed
) == name
)
3380 ptr
= &TREE_VALUE (shadowed
);
3381 /* Can't break out of the loop here because sometimes
3382 a binding level will have duplicate bindings for
3383 PT names. It's gross, but I haven't time to fix it. */
3386 newval
= TREE_TYPE (t
);
3387 if (ptr
== (tree
*)0)
3389 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3390 up here if this is changed to an assertion. --KR */
3391 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3398 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3401 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3402 directive is not directly from the source. Also find the common
3403 ancestor and let our users know about the new namespace */
3405 add_using_namespace (tree user
, tree used
, bool indirect
)
3408 timevar_push (TV_NAME_LOOKUP
);
3409 /* Using oneself is a no-op. */
3412 timevar_pop (TV_NAME_LOOKUP
);
3415 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3416 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3417 /* Check if we already have this. */
3418 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3422 /* Promote to direct usage. */
3423 TREE_INDIRECT_USING (t
) = 0;
3424 timevar_pop (TV_NAME_LOOKUP
);
3428 /* Add used to the user's using list. */
3429 DECL_NAMESPACE_USING (user
)
3430 = tree_cons (used
, namespace_ancestor (user
, used
),
3431 DECL_NAMESPACE_USING (user
));
3433 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3435 /* Add user to the used's users list. */
3436 DECL_NAMESPACE_USERS (used
)
3437 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3439 /* Recursively add all namespaces used. */
3440 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3441 /* indirect usage */
3442 add_using_namespace (user
, TREE_PURPOSE (t
), 1);
3444 /* Tell everyone using us about the new used namespaces. */
3445 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3446 add_using_namespace (TREE_PURPOSE (t
), used
, 1);
3447 timevar_pop (TV_NAME_LOOKUP
);
3450 /* Process a using-declaration not appearing in class or local scope. */
3453 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3455 tree oldval
, oldtype
, newval
, newtype
;
3456 tree orig_decl
= decl
;
3457 cxx_binding
*binding
;
3459 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3460 if (decl
== NULL_TREE
)
3463 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3465 oldval
= binding
->value
;
3466 oldtype
= binding
->type
;
3468 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3470 /* Emit debug info. */
3471 if (!processing_template_decl
)
3472 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3474 /* Copy declarations found. */
3476 binding
->value
= newval
;
3478 binding
->type
= newtype
;
3481 /* Process a using-directive. */
3484 do_using_directive (tree name_space
)
3486 tree context
= NULL_TREE
;
3488 if (name_space
== error_mark_node
)
3491 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3493 if (building_stmt_tree ())
3494 add_stmt (build_stmt (USING_STMT
, name_space
));
3495 name_space
= ORIGINAL_NAMESPACE (name_space
);
3497 if (!toplevel_bindings_p ())
3499 push_using_directive (name_space
);
3504 add_using_namespace (current_namespace
, name_space
, 0);
3505 if (current_namespace
!= global_namespace
)
3506 context
= current_namespace
;
3508 /* Emit debugging info. */
3509 if (!processing_template_decl
)
3510 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
3515 /* Deal with a using-directive seen by the parser. Currently we only
3516 handle attributes here, since they cannot appear inside a template. */
3519 parse_using_directive (tree name_space
, tree attribs
)
3523 do_using_directive (name_space
);
3525 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3527 tree name
= TREE_PURPOSE (a
);
3528 if (is_attribute_p ("strong", name
))
3530 if (!toplevel_bindings_p ())
3531 error ("strong using only meaningful at namespace scope");
3532 else if (name_space
!= error_mark_node
)
3534 if (!is_ancestor (current_namespace
, name_space
))
3535 error ("current namespace %qD does not enclose strongly used namespace %qD",
3536 current_namespace
, name_space
);
3537 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
3538 = tree_cons (current_namespace
, 0,
3539 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
3543 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3547 /* Like pushdecl, only it places X in the global scope if appropriate.
3548 Calls cp_finish_decl to register the variable, initializing it with
3549 *INIT, if INIT is non-NULL. */
3552 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3554 timevar_push (TV_NAME_LOOKUP
);
3555 push_to_top_level ();
3556 x
= pushdecl_namespace_level (x
, is_friend
);
3558 finish_decl (x
, *init
, NULL_TREE
, NULL_TREE
);
3559 pop_from_top_level ();
3560 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
3563 /* Like pushdecl, only it places X in the global scope if appropriate. */
3566 pushdecl_top_level (tree x
)
3568 return pushdecl_top_level_1 (x
, NULL
, false);
3571 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3574 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3576 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3579 /* Like pushdecl, only it places X in the global scope if
3580 appropriate. Calls cp_finish_decl to register the variable,
3581 initializing it with INIT. */
3584 pushdecl_top_level_and_finish (tree x
, tree init
)
3586 return pushdecl_top_level_1 (x
, &init
, false);
3589 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3590 duplicates. The first list becomes the tail of the result.
3592 The algorithm is O(n^2). We could get this down to O(n log n) by
3593 doing a sort on the addresses of the functions, if that becomes
3597 merge_functions (tree s1
, tree s2
)
3599 for (; s2
; s2
= OVL_NEXT (s2
))
3601 tree fn2
= OVL_CURRENT (s2
);
3604 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3606 tree fn1
= OVL_CURRENT (fns1
);
3608 /* If the function from S2 is already in S1, there is no
3609 need to add it again. For `extern "C"' functions, we
3610 might have two FUNCTION_DECLs for the same function, in
3611 different namespaces, but let's leave them in in case
3612 they have different default arguments. */
3617 /* If we exhausted all of the functions in S1, FN2 is new. */
3619 s1
= build_overload (fn2
, s1
);
3624 /* This should return an error not all definitions define functions.
3625 It is not an error if we find two functions with exactly the
3626 same signature, only if these are selected in overload resolution.
3627 old is the current set of bindings, new_binding the freshly-found binding.
3628 XXX Do we want to give *all* candidates in case of ambiguity?
3629 XXX In what way should I treat extern declarations?
3630 XXX I don't want to repeat the entire duplicate_decls here */
3633 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
3636 gcc_assert (old
!= NULL
);
3638 /* Copy the type. */
3639 type
= new_binding
->type
;
3640 if (LOOKUP_NAMESPACES_ONLY (flags
)
3641 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
3644 /* Copy the value. */
3645 val
= new_binding
->value
;
3648 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
3651 switch (TREE_CODE (val
))
3654 /* If we expect types or namespaces, and not templates,
3655 or this is not a template class. */
3656 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3657 && !DECL_CLASS_TEMPLATE_P (val
)))
3661 if (LOOKUP_NAMESPACES_ONLY (flags
)
3662 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
3665 case NAMESPACE_DECL
:
3666 if (LOOKUP_TYPES_ONLY (flags
))
3670 /* Ignore built-in functions that are still anticipated. */
3671 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3675 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3680 /* If val is hidden, shift down any class or enumeration name. */
3689 else if (val
&& val
!= old
->value
)
3691 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3692 old
->value
= merge_functions (old
->value
, val
);
3695 old
->value
= tree_cons (NULL_TREE
, old
->value
,
3696 build_tree_list (NULL_TREE
, val
));
3697 TREE_TYPE (old
->value
) = error_mark_node
;
3703 else if (type
&& old
->type
!= type
)
3705 old
->type
= tree_cons (NULL_TREE
, old
->type
,
3706 build_tree_list (NULL_TREE
, type
));
3707 TREE_TYPE (old
->type
) = error_mark_node
;
3711 /* Return the declarations that are members of the namespace NS. */
3714 cp_namespace_decls (tree ns
)
3716 return NAMESPACE_LEVEL (ns
)->names
;
3719 /* Combine prefer_type and namespaces_only into flags. */
3722 lookup_flags (int prefer_type
, int namespaces_only
)
3724 if (namespaces_only
)
3725 return LOOKUP_PREFER_NAMESPACES
;
3726 if (prefer_type
> 1)
3727 return LOOKUP_PREFER_TYPES
;
3728 if (prefer_type
> 0)
3729 return LOOKUP_PREFER_BOTH
;
3733 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3734 ignore it or not. Subroutine of lookup_name_real and
3735 lookup_type_scope. */
3738 qualify_lookup (tree val
, int flags
)
3740 if (val
== NULL_TREE
)
3742 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3744 if ((flags
& LOOKUP_PREFER_TYPES
)
3745 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3747 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
3752 /* Given a lookup that returned VAL, decide if we want to ignore it or
3753 not based on DECL_ANTICIPATED. */
3756 hidden_name_p (tree val
)
3759 && DECL_LANG_SPECIFIC (val
)
3760 && DECL_ANTICIPATED (val
))
3765 /* Remove any hidden friend functions from a possibly overloaded set
3769 remove_hidden_names (tree fns
)
3774 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
3776 else if (TREE_CODE (fns
) == OVERLOAD
)
3780 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3781 if (hidden_name_p (OVL_CURRENT (o
)))
3787 for (o
= fns
; o
; o
= OVL_NEXT (o
))
3788 if (!hidden_name_p (OVL_CURRENT (o
)))
3789 n
= build_overload (OVL_CURRENT (o
), n
);
3797 /* Unscoped lookup of a global: iterate over current namespaces,
3798 considering using-directives. */
3801 unqualified_namespace_lookup (tree name
, int flags
)
3803 tree initial
= current_decl_namespace ();
3804 tree scope
= initial
;
3806 struct cp_binding_level
*level
;
3807 tree val
= NULL_TREE
;
3809 timevar_push (TV_NAME_LOOKUP
);
3811 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
3813 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3815 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3818 ambiguous_decl (&binding
, b
, flags
);
3820 /* Add all _DECLs seen through local using-directives. */
3821 for (level
= current_binding_level
;
3822 level
->kind
!= sk_namespace
;
3823 level
= level
->level_chain
)
3824 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
3826 /* Give up because of error. */
3827 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3829 /* Add all _DECLs seen through global using-directives. */
3830 /* XXX local and global using lists should work equally. */
3834 if (!lookup_using_namespace (name
, &binding
,
3835 DECL_NAMESPACE_USING (siter
),
3837 /* Give up because of error. */
3838 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3839 if (siter
== scope
) break;
3840 siter
= CP_DECL_CONTEXT (siter
);
3843 val
= binding
.value
;
3844 if (scope
== global_namespace
)
3847 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3850 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3851 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3854 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3855 declaration found. If no suitable declaration can be found,
3856 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3857 neither a class-type nor a namespace a diagnostic is issued. */
3860 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
3865 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3867 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3869 flags
|= LOOKUP_COMPLAIN
;
3871 flags
|= LOOKUP_PREFER_TYPES
;
3872 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
3875 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
3876 t
= lookup_enumerator (scope
, name
);
3877 else if (is_class_type (scope
, complain
))
3878 t
= lookup_member (scope
, name
, 2, is_type_p
);
3881 return error_mark_node
;
3885 /* Subroutine of unqualified_namespace_lookup:
3886 Add the bindings of NAME in used namespaces to VAL.
3887 We are currently looking for names in namespace SCOPE, so we
3888 look through USINGS for using-directives of namespaces
3889 which have SCOPE as a common ancestor with the current scope.
3890 Returns false on errors. */
3893 lookup_using_namespace (tree name
, struct scope_binding
*val
,
3894 tree usings
, tree scope
, int flags
)
3897 timevar_push (TV_NAME_LOOKUP
);
3898 /* Iterate over all used namespaces in current, searching for using
3899 directives of scope. */
3900 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
3901 if (TREE_VALUE (iter
) == scope
)
3903 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
3905 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
3906 /* Resolve ambiguities. */
3908 ambiguous_decl (val
, val1
, flags
);
3910 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
->value
!= error_mark_node
);
3914 Accepts the NAME to lookup and its qualifying SCOPE.
3915 Returns the name/type pair found into the cxx_binding *RESULT,
3916 or false on error. */
3919 qualified_lookup_using_namespace (tree name
, tree scope
,
3920 struct scope_binding
*result
, int flags
)
3922 /* Maintain a list of namespaces visited... */
3923 tree seen
= NULL_TREE
;
3924 /* ... and a list of namespace yet to see. */
3925 tree todo
= NULL_TREE
;
3926 tree todo_maybe
= NULL_TREE
;
3928 timevar_push (TV_NAME_LOOKUP
);
3929 /* Look through namespace aliases. */
3930 scope
= ORIGINAL_NAMESPACE (scope
);
3931 while (scope
&& result
->value
!= error_mark_node
)
3933 cxx_binding
*binding
=
3934 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3935 seen
= tree_cons (scope
, NULL_TREE
, seen
);
3937 ambiguous_decl (result
, binding
, flags
);
3939 /* Consider strong using directives always, and non-strong ones
3940 if we haven't found a binding yet. ??? Shouldn't we consider
3941 non-strong ones if the initial RESULT is non-NULL, but the
3942 binding in the given namespace is? */
3943 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
3944 usings
= TREE_CHAIN (usings
))
3945 /* If this was a real directive, and we have not seen it. */
3946 if (!TREE_INDIRECT_USING (usings
))
3948 /* Try to avoid queuing the same namespace more than once,
3949 the exception being when a namespace was already
3950 enqueued for todo_maybe and then a strong using is
3951 found for it. We could try to remove it from
3952 todo_maybe, but it's probably not worth the effort. */
3953 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
))
3954 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3955 && !purpose_member (TREE_PURPOSE (usings
), todo
))
3956 todo
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
, todo
);
3957 else if ((!result
->value
&& !result
->type
)
3958 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3959 && !purpose_member (TREE_PURPOSE (usings
), todo
)
3960 && !purpose_member (TREE_PURPOSE (usings
), todo_maybe
))
3961 todo_maybe
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
,
3966 scope
= TREE_PURPOSE (todo
);
3967 todo
= TREE_CHAIN (todo
);
3970 && (!result
->value
&& !result
->type
))
3972 scope
= TREE_PURPOSE (todo_maybe
);
3973 todo
= TREE_CHAIN (todo_maybe
);
3974 todo_maybe
= NULL_TREE
;
3977 scope
= NULL_TREE
; /* If there never was a todo list. */
3979 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
->value
!= error_mark_node
);
3982 /* Subroutine of outer_binding.
3983 Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
3987 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
3992 if (!binding
|| !scope
)
3995 binding_value
= binding
->value
? binding
->value
: binding
->type
;
3998 && scope
->this_entity
3999 && get_template_info (scope
->this_entity
)
4000 && parameter_of_template_p (binding_value
,
4001 TI_TEMPLATE (get_template_info \
4002 (scope
->this_entity
))));
4005 /* Return the innermost non-namespace binding for NAME from a scope
4006 containing BINDING, or, if BINDING is NULL, the current scope.
4007 Please note that for a given template, the template parameters are
4008 considered to be in the scope containing the current scope.
4009 If CLASS_P is false, then class bindings are ignored. */
4012 outer_binding (tree name
,
4013 cxx_binding
*binding
,
4018 cxx_scope
*outer_scope
;
4022 scope
= binding
->scope
->level_chain
;
4023 outer
= binding
->previous
;
4027 scope
= current_binding_level
;
4028 outer
= IDENTIFIER_BINDING (name
);
4030 outer_scope
= outer
? outer
->scope
: NULL
;
4032 /* Because we create class bindings lazily, we might be missing a
4033 class binding for NAME. If there are any class binding levels
4034 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4035 declared, we must lookup NAME in those class scopes. */
4037 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4039 if (scope
->kind
== sk_class
)
4041 cxx_binding
*class_binding
;
4043 class_binding
= get_class_binding (name
, scope
);
4046 /* Thread this new class-scope binding onto the
4047 IDENTIFIER_BINDING list so that future lookups
4049 class_binding
->previous
= outer
;
4051 binding
->previous
= class_binding
;
4053 IDENTIFIER_BINDING (name
) = class_binding
;
4054 return class_binding
;
4057 /* If we are in a member template, the template parms of the member
4058 template are considered to be inside the scope of the containing
4059 class, but within G++ the class bindings are all pushed between the
4060 template parms and the function body. So if the outer binding is
4061 a template parm for the current scope, return it now rather than
4062 look for a class binding. */
4063 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4064 && binding_to_template_parms_of_scope_p (outer
, scope
))
4067 scope
= scope
->level_chain
;
4073 /* Return the innermost block-scope or class-scope value binding for
4074 NAME, or NULL_TREE if there is no such binding. */
4077 innermost_non_namespace_value (tree name
)
4079 cxx_binding
*binding
;
4080 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4081 return binding
? binding
->value
: NULL_TREE
;
4084 /* Look up NAME in the current binding level and its superiors in the
4085 namespace of variables, functions and typedefs. Return a ..._DECL
4086 node of some kind representing its definition if there is only one
4087 such declaration, or return a TREE_LIST with all the overloaded
4088 definitions if there are many, or return 0 if it is undefined.
4089 Hidden name, either friend declaration or built-in function, are
4092 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4093 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4094 Otherwise we prefer non-TYPE_DECLs.
4096 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4097 BLOCK_P is false, bindings in block scopes are ignored. */
4100 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4101 int namespaces_only
, int flags
)
4104 tree val
= NULL_TREE
;
4106 timevar_push (TV_NAME_LOOKUP
);
4107 /* Conversion operators are handled specially because ordinary
4108 unqualified name lookup will not find template conversion
4110 if (IDENTIFIER_TYPENAME_P (name
))
4112 struct cp_binding_level
*level
;
4114 for (level
= current_binding_level
;
4115 level
&& level
->kind
!= sk_namespace
;
4116 level
= level
->level_chain
)
4121 /* A conversion operator can only be declared in a class
4123 if (level
->kind
!= sk_class
)
4126 /* Lookup the conversion operator in the class. */
4127 class_type
= level
->this_entity
;
4128 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4130 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, operators
);
4133 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4136 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4138 /* First, look in non-namespace scopes. */
4140 if (current_class_type
== NULL_TREE
)
4143 if (block_p
|| !nonclass
)
4144 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4146 iter
= outer_binding (name
, iter
, !nonclass
))
4150 /* Skip entities we don't want. */
4151 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4154 /* If this is the kind of thing we're looking for, we're done. */
4155 if (qualify_lookup (iter
->value
, flags
))
4156 binding
= iter
->value
;
4157 else if ((flags
& LOOKUP_PREFER_TYPES
)
4158 && qualify_lookup (iter
->type
, flags
))
4159 binding
= iter
->type
;
4161 binding
= NULL_TREE
;
4165 if (hidden_name_p (binding
))
4167 /* A non namespace-scope binding can only be hidden in the
4168 presence of a local class, due to friend declarations.
4170 In particular, consider:
4178 B* b; // error: B is hidden
4179 C* c; // OK, finds ::C
4182 B *b; // error: B is hidden
4183 C *c; // OK, finds ::C
4188 The standard says that "B" is a local class in "f"
4189 (but not nested within "A") -- but that name lookup
4190 for "B" does not find this declaration until it is
4191 declared directly with "f".
4197 If a friend declaration appears in a local class and
4198 the name specified is an unqualified name, a prior
4199 declaration is looked up without considering scopes
4200 that are outside the innermost enclosing non-class
4201 scope. For a friend function declaration, if there is
4202 no prior declaration, the program is ill-formed. For a
4203 friend class declaration, if there is no prior
4204 declaration, the class that is specified belongs to the
4205 innermost enclosing non-class scope, but if it is
4206 subsequently referenced, its name is not found by name
4207 lookup until a matching declaration is provided in the
4208 innermost enclosing nonclass scope.
4210 So just keep looking for a non-hidden binding.
4212 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4220 /* Now lookup in namespace scopes. */
4222 val
= unqualified_namespace_lookup (name
, flags
);
4224 /* If we have a single function from a using decl, pull it out. */
4225 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4226 val
= OVL_FUNCTION (val
);
4228 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4232 lookup_name_nonclass (tree name
)
4234 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4238 lookup_function_nonclass (tree name
, VEC(tree
,gc
) *args
, bool block_p
)
4241 lookup_arg_dependent (name
,
4242 lookup_name_real (name
, 0, 1, block_p
, 0,
4248 lookup_name (tree name
)
4250 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
4254 lookup_name_prefer_type (tree name
, int prefer_type
)
4256 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
4257 0, LOOKUP_COMPLAIN
);
4260 /* Look up NAME for type used in elaborated name specifier in
4261 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4262 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4263 name, more scopes are checked if cleanup or template parameter
4264 scope is encountered.
4266 Unlike lookup_name_real, we make sure that NAME is actually
4267 declared in the desired scope, not from inheritance, nor using
4268 directive. For using declaration, there is DR138 still waiting
4269 to be resolved. Hidden name coming from an earlier friend
4270 declaration is also returned.
4272 A TYPE_DECL best matching the NAME is returned. Catching error
4273 and issuing diagnostics are caller's responsibility. */
4276 lookup_type_scope (tree name
, tag_scope scope
)
4278 cxx_binding
*iter
= NULL
;
4279 tree val
= NULL_TREE
;
4281 timevar_push (TV_NAME_LOOKUP
);
4283 /* Look in non-namespace scope first. */
4284 if (current_binding_level
->kind
!= sk_namespace
)
4285 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4286 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4288 /* Check if this is the kind of thing we're looking for.
4289 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4290 base class. For ITER->VALUE, we can simply use
4291 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4294 We check ITER->TYPE before ITER->VALUE in order to handle
4295 typedef struct C {} C;
4298 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4299 && (scope
!= ts_current
4300 || LOCAL_BINDING_P (iter
)
4301 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4303 else if ((scope
!= ts_current
4304 || !INHERITED_VALUE_BINDING_P (iter
))
4305 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4312 /* Look in namespace scope. */
4315 iter
= cxx_scope_find_binding_for_name
4316 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4320 /* If this is the kind of thing we're looking for, we're done. */
4321 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4323 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4329 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4330 and template parameter scopes. */
4333 struct cp_binding_level
*b
= current_binding_level
;
4336 if (iter
->scope
== b
)
4337 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
4339 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
4340 || b
->kind
== sk_function_parms
)
4342 else if (b
->kind
== sk_class
4343 && scope
== ts_within_enclosing_non_class
)
4350 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4353 /* Similar to `lookup_name' but look only in the innermost non-class
4357 lookup_name_innermost_nonclass_level (tree name
)
4359 struct cp_binding_level
*b
;
4362 timevar_push (TV_NAME_LOOKUP
);
4363 b
= innermost_nonclass_level ();
4365 if (b
->kind
== sk_namespace
)
4367 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4369 /* extern "C" function() */
4370 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4373 else if (IDENTIFIER_BINDING (name
)
4374 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4376 cxx_binding
*binding
;
4377 binding
= IDENTIFIER_BINDING (name
);
4380 if (binding
->scope
== b
4381 && !(TREE_CODE (binding
->value
) == VAR_DECL
4382 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4383 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
->value
);
4385 if (b
->kind
== sk_cleanup
)
4392 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4395 /* Like lookup_name_innermost_nonclass_level, but for types. */
4398 lookup_type_current_level (tree name
)
4402 timevar_push (TV_NAME_LOOKUP
);
4403 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4405 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4406 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4408 struct cp_binding_level
*b
= current_binding_level
;
4411 if (purpose_member (name
, b
->type_shadowed
))
4412 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
4413 REAL_IDENTIFIER_TYPE_VALUE (name
));
4414 if (b
->kind
== sk_cleanup
)
4421 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4424 /* [basic.lookup.koenig] */
4425 /* A nonzero return value in the functions below indicates an error. */
4436 static bool arg_assoc (struct arg_lookup
*, tree
);
4437 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4438 static bool arg_assoc_args_vec (struct arg_lookup
*, VEC(tree
,gc
) *);
4439 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4440 static bool add_function (struct arg_lookup
*, tree
);
4441 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4442 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4443 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4445 /* Add a function to the lookup structure.
4446 Returns true on error. */
4449 add_function (struct arg_lookup
*k
, tree fn
)
4451 /* We used to check here to see if the function was already in the list,
4452 but that's O(n^2), which is just too expensive for function lookup.
4453 Now we deal with the occasional duplicate in joust. In doing this, we
4454 assume that the number of duplicates will be small compared to the
4455 total number of functions being compared, which should usually be the
4458 /* We must find only functions, or exactly one non-function. */
4461 else if (fn
== k
->functions
)
4463 else if (is_overloaded_fn (k
->functions
) && is_overloaded_fn (fn
))
4464 k
->functions
= build_overload (fn
, k
->functions
);
4467 tree f1
= OVL_CURRENT (k
->functions
);
4469 if (is_overloaded_fn (f1
))
4471 fn
= f1
; f1
= f2
; f2
= fn
;
4473 error ("%q+D is not a function,", f1
);
4474 error (" conflict with %q+D", f2
);
4475 error (" in call to %qD", k
->name
);
4482 /* Returns true iff CURRENT has declared itself to be an associated
4483 namespace of SCOPE via a strong using-directive (or transitive chain
4484 thereof). Both are namespaces. */
4487 is_associated_namespace (tree current
, tree scope
)
4489 tree seen
= NULL_TREE
;
4490 tree todo
= NULL_TREE
;
4494 if (scope
== current
)
4496 seen
= tree_cons (scope
, NULL_TREE
, seen
);
4497 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4498 if (!purpose_member (TREE_PURPOSE (t
), seen
))
4499 todo
= tree_cons (TREE_PURPOSE (t
), NULL_TREE
, todo
);
4502 scope
= TREE_PURPOSE (todo
);
4503 todo
= TREE_CHAIN (todo
);
4510 /* Return whether FN is a friend of an associated class of ARG. */
4513 friend_of_associated_class_p (tree arg
, tree fn
)
4519 else if (type_unknown_p (arg
))
4522 type
= TREE_TYPE (arg
);
4524 /* If TYPE is a class, the class itself and all base classes are
4525 associated classes. */
4526 if (CLASS_TYPE_P (type
))
4528 if (is_friend (type
, fn
))
4531 if (TYPE_BINFO (type
))
4533 tree binfo
, base_binfo
;
4536 for (binfo
= TYPE_BINFO (type
), i
= 0;
4537 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
4539 if (is_friend (BINFO_TYPE (base_binfo
), fn
))
4544 /* If TYPE is a class member, the class of which it is a member is
4545 an associated class. */
4546 if ((CLASS_TYPE_P (type
)
4547 || TREE_CODE (type
) == UNION_TYPE
4548 || TREE_CODE (type
) == ENUMERAL_TYPE
)
4549 && TYPE_CONTEXT (type
)
4550 && CLASS_TYPE_P (TYPE_CONTEXT (type
))
4551 && is_friend (TYPE_CONTEXT (type
), fn
))
4557 /* Add functions of a namespace to the lookup structure.
4558 Returns true on error. */
4561 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4565 if (purpose_member (scope
, k
->namespaces
))
4567 k
->namespaces
= tree_cons (scope
, NULL_TREE
, k
->namespaces
);
4569 /* Check out our super-users. */
4570 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4571 value
= TREE_CHAIN (value
))
4572 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4575 /* Also look down into inline namespaces. */
4576 for (value
= DECL_NAMESPACE_USING (scope
); value
;
4577 value
= TREE_CHAIN (value
))
4578 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
4579 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4582 value
= namespace_binding (k
->name
, scope
);
4586 for (; value
; value
= OVL_NEXT (value
))
4588 /* We don't want to find arbitrary hidden functions via argument
4589 dependent lookup. We only want to find friends of associated
4591 if (hidden_name_p (OVL_CURRENT (value
)))
4596 for (ix
= 0; VEC_iterate (tree
, k
->args
, ix
, arg
); ++ix
)
4597 if (friend_of_associated_class_p (arg
, OVL_CURRENT (value
)))
4599 if (ix
>= VEC_length (tree
, k
->args
))
4603 if (add_function (k
, OVL_CURRENT (value
)))
4610 /* Adds everything associated with a template argument to the lookup
4611 structure. Returns true on error. */
4614 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4616 /* [basic.lookup.koenig]
4618 If T is a template-id, its associated namespaces and classes are
4619 ... the namespaces and classes associated with the types of the
4620 template arguments provided for template type parameters
4621 (excluding template template parameters); the namespaces in which
4622 any template template arguments are defined; and the classes in
4623 which any member templates used as template template arguments
4624 are defined. [Note: non-type template arguments do not
4625 contribute to the set of associated namespaces. ] */
4627 /* Consider first template template arguments. */
4628 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4629 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
4631 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
4633 tree ctx
= CP_DECL_CONTEXT (arg
);
4635 /* It's not a member template. */
4636 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4637 return arg_assoc_namespace (k
, ctx
);
4638 /* Otherwise, it must be member template. */
4640 return arg_assoc_class (k
, ctx
);
4642 /* It's an argument pack; handle it recursively. */
4643 else if (ARGUMENT_PACK_P (arg
))
4645 tree args
= ARGUMENT_PACK_ARGS (arg
);
4646 int i
, len
= TREE_VEC_LENGTH (args
);
4647 for (i
= 0; i
< len
; ++i
)
4648 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
4653 /* It's not a template template argument, but it is a type template
4655 else if (TYPE_P (arg
))
4656 return arg_assoc_type (k
, arg
);
4657 /* It's a non-type template argument. */
4662 /* Adds everything associated with class to the lookup structure.
4663 Returns true on error. */
4666 arg_assoc_class (struct arg_lookup
*k
, tree type
)
4668 tree list
, friends
, context
;
4671 /* Backend build structures, such as __builtin_va_list, aren't
4672 affected by all this. */
4673 if (!CLASS_TYPE_P (type
))
4676 if (purpose_member (type
, k
->classes
))
4678 k
->classes
= tree_cons (type
, NULL_TREE
, k
->classes
);
4680 context
= decl_namespace_context (type
);
4681 if (arg_assoc_namespace (k
, context
))
4684 if (TYPE_BINFO (type
))
4686 /* Process baseclasses. */
4687 tree binfo
, base_binfo
;
4689 for (binfo
= TYPE_BINFO (type
), i
= 0;
4690 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4691 if (arg_assoc_class (k
, BINFO_TYPE (base_binfo
)))
4695 /* Process friends. */
4696 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
4697 list
= TREE_CHAIN (list
))
4698 if (k
->name
== FRIEND_NAME (list
))
4699 for (friends
= FRIEND_DECLS (list
); friends
;
4700 friends
= TREE_CHAIN (friends
))
4702 tree fn
= TREE_VALUE (friends
);
4704 /* Only interested in global functions with potentially hidden
4705 (i.e. unqualified) declarations. */
4706 if (CP_DECL_CONTEXT (fn
) != context
)
4708 /* Template specializations are never found by name lookup.
4709 (Templates themselves can be found, but not template
4710 specializations.) */
4711 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
4713 if (add_function (k
, fn
))
4717 /* Process template arguments. */
4718 if (CLASSTYPE_TEMPLATE_INFO (type
)
4719 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
4721 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
4722 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
4723 arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
));
4729 /* Adds everything associated with a given type.
4730 Returns 1 on error. */
4733 arg_assoc_type (struct arg_lookup
*k
, tree type
)
4735 /* As we do not get the type of non-type dependent expressions
4736 right, we can end up with such things without a type. */
4740 if (TYPE_PTRMEM_P (type
))
4742 /* Pointer to member: associate class type and value type. */
4743 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
4745 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
4747 else switch (TREE_CODE (type
))
4757 case FIXED_POINT_TYPE
:
4761 if (TYPE_PTRMEMFUNC_P (type
))
4762 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
4763 return arg_assoc_class (k
, type
);
4765 case REFERENCE_TYPE
:
4767 return arg_assoc_type (k
, TREE_TYPE (type
));
4770 return arg_assoc_namespace (k
, decl_namespace_context (type
));
4772 /* The basetype is referenced in the first arg type, so just
4775 /* Associate the parameter types. */
4776 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
4778 /* Associate the return type. */
4779 return arg_assoc_type (k
, TREE_TYPE (type
));
4780 case TEMPLATE_TYPE_PARM
:
4781 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4786 gcc_assert (type
== unknown_type_node
4787 || type
== init_list_type_node
);
4789 case TYPE_PACK_EXPANSION
:
4790 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
4798 /* Adds everything associated with arguments. Returns true on error. */
4801 arg_assoc_args (struct arg_lookup
*k
, tree args
)
4803 for (; args
; args
= TREE_CHAIN (args
))
4804 if (arg_assoc (k
, TREE_VALUE (args
)))
4809 /* Adds everything associated with an argument vector. Returns true
4813 arg_assoc_args_vec (struct arg_lookup
*k
, VEC(tree
,gc
) *args
)
4818 for (ix
= 0; VEC_iterate (tree
, args
, ix
, arg
); ++ix
)
4819 if (arg_assoc (k
, arg
))
4824 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4827 arg_assoc (struct arg_lookup
*k
, tree n
)
4829 if (n
== error_mark_node
)
4833 return arg_assoc_type (k
, n
);
4835 if (! type_unknown_p (n
))
4836 return arg_assoc_type (k
, TREE_TYPE (n
));
4838 if (TREE_CODE (n
) == ADDR_EXPR
)
4839 n
= TREE_OPERAND (n
, 0);
4840 if (TREE_CODE (n
) == COMPONENT_REF
)
4841 n
= TREE_OPERAND (n
, 1);
4842 if (TREE_CODE (n
) == OFFSET_REF
)
4843 n
= TREE_OPERAND (n
, 1);
4844 while (TREE_CODE (n
) == TREE_LIST
)
4846 if (TREE_CODE (n
) == BASELINK
)
4847 n
= BASELINK_FUNCTIONS (n
);
4849 if (TREE_CODE (n
) == FUNCTION_DECL
)
4850 return arg_assoc_type (k
, TREE_TYPE (n
));
4851 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
4853 /* [basic.lookup.koenig]
4855 If T is a template-id, its associated namespaces and classes
4856 are the namespace in which the template is defined; for
4857 member templates, the member template's class... */
4858 tree templ
= TREE_OPERAND (n
, 0);
4859 tree args
= TREE_OPERAND (n
, 1);
4863 if (TREE_CODE (templ
) == COMPONENT_REF
)
4864 templ
= TREE_OPERAND (templ
, 1);
4866 /* First, the template. There may actually be more than one if
4867 this is an overloaded function template. But, in that case,
4868 we only need the first; all the functions will be in the same
4870 templ
= OVL_CURRENT (templ
);
4872 ctx
= CP_DECL_CONTEXT (templ
);
4874 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4876 if (arg_assoc_namespace (k
, ctx
) == 1)
4879 /* It must be a member template. */
4880 else if (arg_assoc_class (k
, ctx
) == 1)
4883 /* Now the arguments. */
4885 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
4886 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
4889 else if (TREE_CODE (n
) == OVERLOAD
)
4891 for (; n
; n
= OVL_CHAIN (n
))
4892 if (arg_assoc_type (k
, TREE_TYPE (OVL_FUNCTION (n
))))
4899 /* Performs Koenig lookup depending on arguments, where fns
4900 are the functions found in normal lookup. */
4903 lookup_arg_dependent (tree name
, tree fns
, VEC(tree
,gc
) *args
)
4905 struct arg_lookup k
;
4907 timevar_push (TV_NAME_LOOKUP
);
4909 /* Remove any hidden friend functions from the list of functions
4910 found so far. They will be added back by arg_assoc_class as
4912 fns
= remove_hidden_names (fns
);
4917 k
.classes
= NULL_TREE
;
4919 /* We previously performed an optimization here by setting
4920 NAMESPACES to the current namespace when it was safe. However, DR
4921 164 says that namespaces that were already searched in the first
4922 stage of template processing are searched again (potentially
4923 picking up later definitions) in the second stage. */
4924 k
.namespaces
= NULL_TREE
;
4926 arg_assoc_args_vec (&k
, args
);
4931 && TREE_CODE (fns
) != VAR_DECL
4932 && !is_overloaded_fn (fns
))
4934 error ("argument dependent lookup finds %q+D", fns
);
4935 error (" in call to %qD", name
);
4936 fns
= error_mark_node
;
4939 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, fns
);
4942 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4943 changed (i.e. there was already a directive), or the fresh
4944 TREE_LIST otherwise. */
4947 push_using_directive (tree used
)
4949 tree ud
= current_binding_level
->using_directives
;
4950 tree iter
, ancestor
;
4952 timevar_push (TV_NAME_LOOKUP
);
4953 /* Check if we already have this. */
4954 if (purpose_member (used
, ud
) != NULL_TREE
)
4955 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4957 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4958 ud
= current_binding_level
->using_directives
;
4959 ud
= tree_cons (used
, ancestor
, ud
);
4960 current_binding_level
->using_directives
= ud
;
4962 /* Recursively add all namespaces used. */
4963 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4964 push_using_directive (TREE_PURPOSE (iter
));
4966 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ud
);
4969 /* The type TYPE is being declared. If it is a class template, or a
4970 specialization of a class template, do any processing required and
4971 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4972 being declared a friend. B is the binding level at which this TYPE
4975 Returns the TYPE_DECL for TYPE, which may have been altered by this
4979 maybe_process_template_type_declaration (tree type
, int is_friend
,
4982 tree decl
= TYPE_NAME (type
);
4984 if (processing_template_parmlist
)
4985 /* You can't declare a new template type in a template parameter
4986 list. But, you can declare a non-template type:
4988 template <class A*> struct S;
4990 is a forward-declaration of `A'. */
4992 else if (b
->kind
== sk_namespace
4993 && current_binding_level
->kind
!= sk_namespace
)
4994 /* If this new type is being injected into a containing scope,
4995 then it's not a template type. */
4999 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5000 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5002 if (processing_template_decl
)
5004 /* This may change after the call to
5005 push_template_decl_real, but we want the original value. */
5006 tree name
= DECL_NAME (decl
);
5008 decl
= push_template_decl_real (decl
, is_friend
);
5009 if (decl
== error_mark_node
)
5010 return error_mark_node
;
5012 /* If the current binding level is the binding level for the
5013 template parameters (see the comment in
5014 begin_template_parm_list) and the enclosing level is a class
5015 scope, and we're not looking at a friend, push the
5016 declaration of the member class into the class scope. In the
5017 friend case, push_template_decl will already have put the
5018 friend into global scope, if appropriate. */
5019 if (TREE_CODE (type
) != ENUMERAL_TYPE
5020 && !is_friend
&& b
->kind
== sk_template_parms
5021 && b
->level_chain
->kind
== sk_class
)
5023 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5025 if (!COMPLETE_TYPE_P (current_class_type
))
5027 maybe_add_class_template_decl_list (current_class_type
,
5028 type
, /*friend_p=*/0);
5029 /* Put this UTD in the table of UTDs for the class. */
5030 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5031 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5032 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5034 binding_table_insert
5035 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5044 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5045 that the NAME is a class template, the tag is processed but not pushed.
5047 The pushed scope depend on the SCOPE parameter:
5048 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5050 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5051 non-template-parameter scope. This case is needed for forward
5053 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5054 TS_GLOBAL case except that names within template-parameter scopes
5055 are not pushed at all.
5057 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5060 pushtag (tree name
, tree type
, tag_scope scope
)
5062 struct cp_binding_level
*b
;
5065 timevar_push (TV_NAME_LOOKUP
);
5066 b
= current_binding_level
;
5067 while (/* Cleanup scopes are not scopes from the point of view of
5069 b
->kind
== sk_cleanup
5070 /* Neither are function parameter scopes. */
5071 || b
->kind
== sk_function_parms
5072 /* Neither are the scopes used to hold template parameters
5073 for an explicit specialization. For an ordinary template
5074 declaration, these scopes are not scopes from the point of
5075 view of the language. */
5076 || (b
->kind
== sk_template_parms
5077 && (b
->explicit_spec_p
|| scope
== ts_global
))
5078 || (b
->kind
== sk_class
5079 && (scope
!= ts_current
5080 /* We may be defining a new type in the initializer
5081 of a static member variable. We allow this when
5082 not pedantic, and it is particularly useful for
5083 type punning via an anonymous union. */
5084 || COMPLETE_TYPE_P (b
->this_entity
))))
5087 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5089 /* Do C++ gratuitous typedefing. */
5090 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
5094 tree context
= TYPE_CONTEXT (type
);
5098 tree cs
= current_scope ();
5100 if (scope
== ts_current
)
5102 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5103 /* When declaring a friend class of a local class, we want
5104 to inject the newly named class into the scope
5105 containing the local class, not the namespace
5107 context
= decl_function_context (get_type_decl (cs
));
5110 context
= current_namespace
;
5112 if (b
->kind
== sk_class
5113 || (b
->kind
== sk_template_parms
5114 && b
->level_chain
->kind
== sk_class
))
5117 if (current_lang_name
== lang_name_java
)
5118 TYPE_FOR_JAVA (type
) = 1;
5120 tdef
= create_implicit_typedef (name
, type
);
5121 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5122 if (scope
== ts_within_enclosing_non_class
)
5124 /* This is a friend. Make this TYPE_DECL node hidden from
5125 ordinary name lookup. Its corresponding TEMPLATE_DECL
5126 will be marked in push_template_decl_real. */
5127 retrofit_lang_decl (tdef
);
5128 DECL_ANTICIPATED (tdef
) = 1;
5129 DECL_FRIEND_P (tdef
) = 1;
5132 decl
= maybe_process_template_type_declaration
5133 (type
, scope
== ts_within_enclosing_non_class
, b
);
5134 if (decl
== error_mark_node
)
5135 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
5137 if (b
->kind
== sk_class
)
5139 if (!TYPE_BEING_DEFINED (current_class_type
))
5140 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5142 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5143 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5144 class. But if it's a member template class, we want
5145 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5147 finish_member_declaration (decl
);
5149 pushdecl_class_level (decl
);
5151 else if (b
->kind
!= sk_template_parms
)
5153 decl
= pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
5154 if (decl
== error_mark_node
)
5155 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
5159 set_identifier_type_value_with_scope (name
, tdef
, b
);
5161 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5163 /* If this is a local class, keep track of it. We need this
5164 information for name-mangling, and so that it is possible to
5165 find all function definitions in a translation unit in a
5166 convenient way. (It's otherwise tricky to find a member
5167 function definition it's only pointed to from within a local
5169 if (TYPE_CONTEXT (type
)
5170 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
5171 VEC_safe_push (tree
, gc
, local_classes
, type
);
5173 if (b
->kind
== sk_class
5174 && !COMPLETE_TYPE_P (current_class_type
))
5176 maybe_add_class_template_decl_list (current_class_type
,
5177 type
, /*friend_p=*/0);
5179 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5180 CLASSTYPE_NESTED_UTDS (current_class_type
)
5181 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5183 binding_table_insert
5184 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5187 decl
= TYPE_NAME (type
);
5188 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
5189 TYPE_STUB_DECL (type
) = decl
;
5191 /* Set type visibility now if this is a forward declaration. */
5192 TREE_PUBLIC (decl
) = 1;
5193 determine_visibility (decl
);
5195 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, type
);
5198 /* Subroutines for reverting temporarily to top-level for instantiation
5199 of templates and such. We actually need to clear out the class- and
5200 local-value slots of all identifiers, so that only the global values
5201 are at all visible. Simply setting current_binding_level to the global
5202 scope isn't enough, because more binding levels may be pushed. */
5203 struct saved_scope
*scope_chain
;
5205 /* If ID has not already been marked, add an appropriate binding to
5209 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5211 cxx_saved_binding
*saved
;
5213 if (!id
|| !IDENTIFIER_BINDING (id
))
5216 if (IDENTIFIER_MARKED (id
))
5219 IDENTIFIER_MARKED (id
) = 1;
5221 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
5222 saved
->identifier
= id
;
5223 saved
->binding
= IDENTIFIER_BINDING (id
);
5224 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
5225 IDENTIFIER_BINDING (id
) = NULL
;
5229 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5233 timevar_push (TV_NAME_LOOKUP
);
5234 for (t
= names
; t
; t
= TREE_CHAIN (t
))
5238 if (TREE_CODE (t
) == TREE_LIST
)
5239 id
= TREE_PURPOSE (t
);
5243 store_binding (id
, old_bindings
);
5245 timevar_pop (TV_NAME_LOOKUP
);
5248 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5249 objects, rather than a TREE_LIST. */
5252 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
5253 VEC(cxx_saved_binding
,gc
) **old_bindings
)
5256 cp_class_binding
*cb
;
5258 timevar_push (TV_NAME_LOOKUP
);
5259 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
5260 store_binding (cb
->identifier
, old_bindings
);
5261 timevar_pop (TV_NAME_LOOKUP
);
5265 push_to_top_level (void)
5267 struct saved_scope
*s
;
5268 struct cp_binding_level
*b
;
5269 cxx_saved_binding
*sb
;
5273 timevar_push (TV_NAME_LOOKUP
);
5274 s
= GGC_CNEW (struct saved_scope
);
5276 b
= scope_chain
? current_binding_level
: 0;
5278 /* If we're in the middle of some function, save our state. */
5282 push_function_context ();
5287 if (scope_chain
&& previous_class_level
)
5288 store_class_bindings (previous_class_level
->class_shadowed
,
5291 /* Have to include the global scope, because class-scope decls
5292 aren't listed anywhere useful. */
5293 for (; b
; b
= b
->level_chain
)
5297 /* Template IDs are inserted into the global level. If they were
5298 inserted into namespace level, finish_file wouldn't find them
5299 when doing pending instantiations. Therefore, don't stop at
5300 namespace level, but continue until :: . */
5301 if (global_scope_p (b
))
5304 store_bindings (b
->names
, &s
->old_bindings
);
5305 /* We also need to check class_shadowed to save class-level type
5306 bindings, since pushclass doesn't fill in b->names. */
5307 if (b
->kind
== sk_class
)
5308 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
5310 /* Unwind type-value slots back to top level. */
5311 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
5312 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
5315 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, sb
); ++i
)
5316 IDENTIFIER_MARKED (sb
->identifier
) = 0;
5318 s
->prev
= scope_chain
;
5320 s
->need_pop_function_context
= need_pop
;
5321 s
->function_decl
= current_function_decl
;
5322 s
->skip_evaluation
= skip_evaluation
;
5325 current_function_decl
= NULL_TREE
;
5326 current_lang_base
= VEC_alloc (tree
, gc
, 10);
5327 current_lang_name
= lang_name_cplusplus
;
5328 current_namespace
= global_namespace
;
5329 push_class_stack ();
5330 skip_evaluation
= 0;
5331 timevar_pop (TV_NAME_LOOKUP
);
5335 pop_from_top_level (void)
5337 struct saved_scope
*s
= scope_chain
;
5338 cxx_saved_binding
*saved
;
5341 timevar_push (TV_NAME_LOOKUP
);
5342 /* Clear out class-level bindings cache. */
5343 if (previous_class_level
)
5344 invalidate_class_lookup_cache ();
5347 current_lang_base
= 0;
5349 scope_chain
= s
->prev
;
5350 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, saved
); ++i
)
5352 tree id
= saved
->identifier
;
5354 IDENTIFIER_BINDING (id
) = saved
->binding
;
5355 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
5358 /* If we were in the middle of compiling a function, restore our
5360 if (s
->need_pop_function_context
)
5361 pop_function_context ();
5362 current_function_decl
= s
->function_decl
;
5363 skip_evaluation
= s
->skip_evaluation
;
5364 timevar_pop (TV_NAME_LOOKUP
);
5367 /* Pop off extraneous binding levels left over due to syntax errors.
5369 We don't pop past namespaces, as they might be valid. */
5372 pop_everything (void)
5374 if (ENABLE_SCOPE_CHECKING
)
5375 verbatim ("XXX entering pop_everything ()\n");
5376 while (!toplevel_bindings_p ())
5378 if (current_binding_level
->kind
== sk_class
)
5379 pop_nested_class ();
5383 if (ENABLE_SCOPE_CHECKING
)
5384 verbatim ("XXX leaving pop_everything ()\n");
5387 /* Emit debugging information for using declarations and directives.
5388 If input tree is overloaded fn then emit debug info for all
5392 cp_emit_debug_info_for_using (tree t
, tree context
)
5394 /* Don't try to emit any debug information if we have errors. */
5395 if (sorrycount
|| errorcount
)
5398 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5399 of a builtin function. */
5400 if (TREE_CODE (t
) == FUNCTION_DECL
5401 && DECL_EXTERNAL (t
)
5402 && DECL_BUILT_IN (t
))
5405 /* Do not supply context to imported_module_or_decl, if
5406 it is a global namespace. */
5407 if (context
== global_namespace
)
5408 context
= NULL_TREE
;
5411 t
= BASELINK_FUNCTIONS (t
);
5413 /* FIXME: Handle TEMPLATE_DECLs. */
5414 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
5415 if (TREE_CODE (t
) != TEMPLATE_DECL
)
5417 if (building_stmt_tree ())
5418 add_stmt (build_stmt (USING_STMT
, t
));
5420 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
5424 #include "gt-cp-name-lookup.h"