1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
32 #include "diagnostic.h"
35 /* The bindings for a particular name in a particular scope. */
37 struct scope_binding
{
41 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
43 static cxx_scope
*innermost_nonclass_level (void);
44 static tree
select_decl (const struct scope_binding
*, int);
45 static cxx_binding
*binding_for_name (cxx_scope
*, tree
);
46 static tree
lookup_name_innermost_nonclass_level (tree
);
47 static tree
push_overloaded_decl (tree
, int);
48 static bool lookup_using_namespace (tree
, struct scope_binding
*, tree
,
50 static bool qualified_lookup_using_namespace (tree
, tree
,
51 struct scope_binding
*, int);
52 static tree
lookup_type_current_level (tree
);
53 static tree
push_using_directive (tree
);
54 static void cp_emit_debug_info_for_using (tree
, tree
);
56 /* The :: namespace. */
58 tree global_namespace
;
60 /* The name of the anonymous namespace, throughout this translation
62 static GTY(()) tree anonymous_namespace_name
;
65 /* Compute the chain index of a binding_entry given the HASH value of its
66 name and the total COUNT of chains. COUNT is assumed to be a power
69 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
71 /* A free list of "binding_entry"s awaiting for re-use. */
73 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
75 /* Create a binding_entry object for (NAME, TYPE). */
77 static inline binding_entry
78 binding_entry_make (tree name
, tree type
)
82 if (free_binding_entry
)
84 entry
= free_binding_entry
;
85 free_binding_entry
= entry
->chain
;
88 entry
= GGC_NEW (struct binding_entry_s
);
97 /* Put ENTRY back on the free list. */
100 binding_entry_free (binding_entry entry
)
104 entry
->chain
= free_binding_entry
;
105 free_binding_entry
= entry
;
109 /* The datatype used to implement the mapping from names to types at
111 struct binding_table_s
GTY(())
113 /* Array of chains of "binding_entry"s */
114 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
116 /* The number of chains in this table. This is the length of the
117 the member "chain" considered as an array. */
120 /* Number of "binding_entry"s in this table. */
124 /* Construct TABLE with an initial CHAIN_COUNT. */
127 binding_table_construct (binding_table table
, size_t chain_count
)
129 table
->chain_count
= chain_count
;
130 table
->entry_count
= 0;
131 table
->chain
= GGC_CNEWVEC (binding_entry
, table
->chain_count
);
134 /* Make TABLE's entries ready for reuse. */
137 binding_table_free (binding_table table
)
145 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
147 binding_entry temp
= table
->chain
[i
];
150 binding_entry entry
= temp
;
152 binding_entry_free (entry
);
154 table
->chain
[i
] = NULL
;
156 table
->entry_count
= 0;
160 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
162 static inline binding_table
163 binding_table_new (size_t chain_count
)
165 binding_table table
= GGC_NEW (struct binding_table_s
);
167 binding_table_construct (table
, chain_count
);
171 /* Expand TABLE to twice its current chain_count. */
174 binding_table_expand (binding_table table
)
176 const size_t old_chain_count
= table
->chain_count
;
177 const size_t old_entry_count
= table
->entry_count
;
178 const size_t new_chain_count
= 2 * old_chain_count
;
179 binding_entry
*old_chains
= table
->chain
;
182 binding_table_construct (table
, new_chain_count
);
183 for (i
= 0; i
< old_chain_count
; ++i
)
185 binding_entry entry
= old_chains
[i
];
186 for (; entry
!= NULL
; entry
= old_chains
[i
])
188 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
189 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
191 old_chains
[i
] = entry
->chain
;
192 entry
->chain
= table
->chain
[j
];
193 table
->chain
[j
] = entry
;
196 table
->entry_count
= old_entry_count
;
199 /* Insert a binding for NAME to TYPE into TABLE. */
202 binding_table_insert (binding_table table
, tree name
, tree type
)
204 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
205 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
206 binding_entry entry
= binding_entry_make (name
, type
);
208 entry
->chain
= table
->chain
[i
];
209 table
->chain
[i
] = entry
;
210 ++table
->entry_count
;
212 if (3 * table
->chain_count
< 5 * table
->entry_count
)
213 binding_table_expand (table
);
216 /* Return the binding_entry, if any, that maps NAME. */
219 binding_table_find (binding_table table
, tree name
)
221 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
222 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
224 while (entry
!= NULL
&& entry
->name
!= name
)
225 entry
= entry
->chain
;
230 /* Apply PROC -- with DATA -- to all entries in TABLE. */
233 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
235 const size_t chain_count
= table
->chain_count
;
238 for (i
= 0; i
< chain_count
; ++i
)
240 binding_entry entry
= table
->chain
[i
];
241 for (; entry
!= NULL
; entry
= entry
->chain
)
246 #ifndef ENABLE_SCOPE_CHECKING
247 # define ENABLE_SCOPE_CHECKING 0
249 # define ENABLE_SCOPE_CHECKING 1
252 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
254 static GTY((deletable
)) cxx_binding
*free_bindings
;
256 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
260 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
262 binding
->value
= value
;
263 binding
->type
= type
;
264 binding
->previous
= NULL
;
267 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
270 cxx_binding_make (tree value
, tree type
)
272 cxx_binding
*binding
;
275 binding
= free_bindings
;
276 free_bindings
= binding
->previous
;
279 binding
= GGC_NEW (cxx_binding
);
281 cxx_binding_init (binding
, value
, type
);
286 /* Put BINDING back on the free list. */
289 cxx_binding_free (cxx_binding
*binding
)
291 binding
->scope
= NULL
;
292 binding
->previous
= free_bindings
;
293 free_bindings
= binding
;
296 /* Create a new binding for NAME (with the indicated VALUE and TYPE
297 bindings) in the class scope indicated by SCOPE. */
300 new_class_binding (tree name
, tree value
, tree type
, cxx_scope
*scope
)
302 cp_class_binding
*cb
;
303 cxx_binding
*binding
;
305 if (VEC_length (cp_class_binding
, scope
->class_shadowed
))
307 cp_class_binding
*old_base
;
308 old_base
= VEC_index (cp_class_binding
, scope
->class_shadowed
, 0);
309 if (VEC_reserve (cp_class_binding
, gc
, scope
->class_shadowed
, 1))
311 /* Fixup the current bindings, as they might have moved. */
315 VEC_iterate (cp_class_binding
, scope
->class_shadowed
, i
, cb
);
319 b
= &IDENTIFIER_BINDING (cb
->identifier
);
320 while (*b
!= &old_base
[i
].base
)
321 b
= &((*b
)->previous
);
325 cb
= VEC_quick_push (cp_class_binding
, scope
->class_shadowed
, NULL
);
328 cb
= VEC_safe_push (cp_class_binding
, gc
, scope
->class_shadowed
, NULL
);
330 cb
->identifier
= name
;
332 binding
->scope
= scope
;
333 cxx_binding_init (binding
, value
, type
);
337 /* Make DECL the innermost binding for ID. The LEVEL is the binding
338 level at which this declaration is being bound. */
341 push_binding (tree id
, tree decl
, cxx_scope
* level
)
343 cxx_binding
*binding
;
345 if (level
!= class_binding_level
)
347 binding
= cxx_binding_make (decl
, NULL_TREE
);
348 binding
->scope
= level
;
351 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
353 /* Now, fill in the binding information. */
354 binding
->previous
= IDENTIFIER_BINDING (id
);
355 INHERITED_VALUE_BINDING_P (binding
) = 0;
356 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
358 /* And put it on the front of the list of bindings for ID. */
359 IDENTIFIER_BINDING (id
) = binding
;
362 /* Remove the binding for DECL which should be the innermost binding
366 pop_binding (tree id
, tree decl
)
368 cxx_binding
*binding
;
371 /* It's easiest to write the loops that call this function without
372 checking whether or not the entities involved have names. We
373 get here for such an entity. */
376 /* Get the innermost binding for ID. */
377 binding
= IDENTIFIER_BINDING (id
);
379 /* The name should be bound. */
380 gcc_assert (binding
!= NULL
);
382 /* The DECL will be either the ordinary binding or the type
383 binding for this identifier. Remove that binding. */
384 if (binding
->value
== decl
)
385 binding
->value
= NULL_TREE
;
388 gcc_assert (binding
->type
== decl
);
389 binding
->type
= NULL_TREE
;
392 if (!binding
->value
&& !binding
->type
)
394 /* We're completely done with the innermost binding for this
395 identifier. Unhook it from the list of bindings. */
396 IDENTIFIER_BINDING (id
) = binding
->previous
;
398 /* Add it to the free list. */
399 cxx_binding_free (binding
);
403 /* BINDING records an existing declaration for a namein the current scope.
404 But, DECL is another declaration for that same identifier in the
405 same scope. This is the `struct stat' hack whereby a non-typedef
406 class name or enum-name can be bound at the same level as some other
410 A class name (9.1) or enumeration name (7.2) can be hidden by the
411 name of an object, function, or enumerator declared in the same scope.
412 If a class or enumeration name and an object, function, or enumerator
413 are declared in the same scope (in any order) with the same name, the
414 class or enumeration name is hidden wherever the object, function, or
415 enumerator name is visible.
417 It's the responsibility of the caller to check that
418 inserting this name is valid here. Returns nonzero if the new binding
422 supplement_binding (cxx_binding
*binding
, tree decl
)
424 tree bval
= binding
->value
;
427 timevar_push (TV_NAME_LOOKUP
);
428 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
429 /* The new name is the type name. */
430 binding
->type
= decl
;
431 else if (/* BVAL is null when push_class_level_binding moves an
432 inherited type-binding out of the way to make room for a
433 new value binding. */
435 /* BVAL is error_mark_node when DECL's name has been used
436 in a non-class scope prior declaration. In that case,
437 we should have already issued a diagnostic; for graceful
438 error recovery purpose, pretend this was the intended
439 declaration for that name. */
440 || bval
== error_mark_node
441 /* If BVAL is a built-in that has not yet been declared,
442 pretend it is not there at all. */
443 || (TREE_CODE (bval
) == FUNCTION_DECL
444 && DECL_ANTICIPATED (bval
)))
445 binding
->value
= decl
;
446 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
448 /* The old binding was a type name. It was placed in
449 VALUE field because it was thought, at the point it was
450 declared, to be the only entity with such a name. Move the
451 type name into the type slot; it is now hidden by the new
453 binding
->type
= bval
;
454 binding
->value
= decl
;
455 binding
->value_is_inherited
= false;
457 else if (TREE_CODE (bval
) == TYPE_DECL
458 && TREE_CODE (decl
) == TYPE_DECL
459 && DECL_NAME (decl
) == DECL_NAME (bval
)
460 && binding
->scope
->kind
!= sk_class
461 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
462 /* If either type involves template parameters, we must
463 wait until instantiation. */
464 || uses_template_parms (TREE_TYPE (decl
))
465 || uses_template_parms (TREE_TYPE (bval
))))
466 /* We have two typedef-names, both naming the same type to have
467 the same name. In general, this is OK because of:
471 In a given scope, a typedef specifier can be used to redefine
472 the name of any type declared in that scope to refer to the
473 type to which it already refers.
475 However, in class scopes, this rule does not apply due to the
476 stricter language in [class.mem] prohibiting redeclarations of
479 /* There can be two block-scope declarations of the same variable,
480 so long as they are `extern' declarations. However, there cannot
481 be two declarations of the same static data member:
485 A member shall not be declared twice in the
486 member-specification. */
487 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
488 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
489 && !DECL_CLASS_SCOPE_P (decl
))
491 duplicate_decls (decl
, binding
->value
);
494 else if (TREE_CODE (decl
) == NAMESPACE_DECL
495 && TREE_CODE (bval
) == NAMESPACE_DECL
496 && DECL_NAMESPACE_ALIAS (decl
)
497 && DECL_NAMESPACE_ALIAS (bval
)
498 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
501 In a declarative region, a namespace-alias-definition can be
502 used to redefine a namespace-alias declared in that declarative
503 region to refer only to the namespace to which it already
508 error ("declaration of %q#D", decl
);
509 cp_error_at ("conflicts with previous declaration %q#D", bval
);
513 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
516 /* Add DECL to the list of things declared in B. */
519 add_decl_to_level (tree decl
, cxx_scope
*b
)
521 if (TREE_CODE (decl
) == NAMESPACE_DECL
522 && !DECL_NAMESPACE_ALIAS (decl
))
524 TREE_CHAIN (decl
) = b
->namespaces
;
525 b
->namespaces
= decl
;
527 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
529 TREE_CHAIN (decl
) = b
->vtables
;
534 /* We build up the list in reverse order, and reverse it later if
536 TREE_CHAIN (decl
) = b
->names
;
540 /* If appropriate, add decl to separate list of statics. We
541 include extern variables because they might turn out to be
542 static later. It's OK for this list to contain a few false
544 if (b
->kind
== sk_namespace
)
545 if ((TREE_CODE (decl
) == VAR_DECL
546 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
547 || (TREE_CODE (decl
) == FUNCTION_DECL
548 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
549 VARRAY_PUSH_TREE (b
->static_decls
, decl
);
553 /* Record a decl-node X as belonging to the current lexical scope.
554 Check for errors (such as an incompatible declaration for the same
555 name already seen in the same scope).
557 Returns either X or an old decl for the same name.
558 If an old decl is returned, it may have been smashed
559 to agree with what X says. */
566 int need_new_binding
;
568 timevar_push (TV_NAME_LOOKUP
);
570 need_new_binding
= 1;
572 if (DECL_TEMPLATE_PARM_P (x
))
573 /* Template parameters have no context; they are not X::T even
574 when declared within a class or namespace. */
578 if (current_function_decl
&& x
!= current_function_decl
579 /* A local declaration for a function doesn't constitute
581 && TREE_CODE (x
) != FUNCTION_DECL
582 /* A local declaration for an `extern' variable is in the
583 scope of the current namespace, not the current
585 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
586 && !DECL_CONTEXT (x
))
587 DECL_CONTEXT (x
) = current_function_decl
;
589 /* If this is the declaration for a namespace-scope function,
590 but the declaration itself is in a local scope, mark the
592 if (TREE_CODE (x
) == FUNCTION_DECL
593 && DECL_NAMESPACE_SCOPE_P (x
)
594 && current_function_decl
595 && x
!= current_function_decl
)
596 DECL_LOCAL_FUNCTION_P (x
) = 1;
599 name
= DECL_NAME (x
);
602 int different_binding_level
= 0;
604 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
605 name
= TREE_OPERAND (name
, 0);
607 /* In case this decl was explicitly namespace-qualified, look it
608 up in its namespace context. */
609 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
610 t
= namespace_binding (name
, DECL_CONTEXT (x
));
612 t
= lookup_name_innermost_nonclass_level (name
);
614 /* [basic.link] If there is a visible declaration of an entity
615 with linkage having the same name and type, ignoring entities
616 declared outside the innermost enclosing namespace scope, the
617 block scope declaration declares that same entity and
618 receives the linkage of the previous declaration. */
619 if (! t
&& current_function_decl
&& x
!= current_function_decl
620 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
621 && DECL_EXTERNAL (x
))
623 /* Look in block scope. */
624 t
= innermost_non_namespace_value (name
);
625 /* Or in the innermost namespace. */
627 t
= namespace_binding (name
, DECL_CONTEXT (x
));
628 /* Does it have linkage? Note that if this isn't a DECL, it's an
629 OVERLOAD, which is OK. */
630 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
633 different_binding_level
= 1;
636 /* If we are declaring a function, and the result of name-lookup
637 was an OVERLOAD, look for an overloaded instance that is
638 actually the same as the function we are declaring. (If
639 there is one, we have to merge our declaration with the
640 previous declaration.) */
641 if (t
&& TREE_CODE (t
) == OVERLOAD
)
645 if (TREE_CODE (x
) == FUNCTION_DECL
)
646 for (match
= t
; match
; match
= OVL_NEXT (match
))
648 if (decls_match (OVL_CURRENT (match
), x
))
652 /* Just choose one. */
656 t
= OVL_CURRENT (match
);
661 if (t
&& t
!= error_mark_node
)
663 if (different_binding_level
)
665 if (decls_match (x
, t
))
666 /* The standard only says that the local extern
667 inherits linkage from the previous decl; in
668 particular, default args are not shared. We must
669 also tell cgraph to treat these decls as the same,
670 or we may neglect to emit an "unused" static - we
671 do this by making the DECL_UIDs equal, which should
672 be viewed as a kludge. FIXME. */
674 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
675 DECL_UID (x
) = DECL_UID (t
);
678 else if (TREE_CODE (t
) == PARM_DECL
)
680 gcc_assert (DECL_CONTEXT (t
));
682 /* Check for duplicate params. */
683 if (duplicate_decls (x
, t
))
684 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
686 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
687 || DECL_FUNCTION_TEMPLATE_P (x
))
688 && is_overloaded_fn (t
))
689 /* Don't do anything just yet. */;
690 else if (t
== wchar_decl_node
)
692 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
693 pedwarn ("redeclaration of %<wchar_t%> as %qT",
696 /* Throw away the redeclaration. */
697 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
701 tree olddecl
= duplicate_decls (x
, t
);
703 /* If the redeclaration failed, we can stop at this
705 if (olddecl
== error_mark_node
)
706 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
710 if (TREE_CODE (t
) == TYPE_DECL
)
711 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
712 else if (TREE_CODE (t
) == FUNCTION_DECL
)
713 check_default_args (t
);
715 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
717 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
719 /* A redeclaration of main, but not a duplicate of the
724 This function shall not be overloaded. */
725 cp_error_at ("invalid redeclaration of %qD", t
);
727 /* We don't try to push this declaration since that
729 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
734 check_template_shadow (x
);
736 /* If this is a function conjured up by the backend, massage it
737 so it looks friendly. */
738 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
740 retrofit_lang_decl (x
);
741 SET_DECL_LANGUAGE (x
, lang_c
);
744 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
746 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
749 if (!namespace_bindings_p ())
750 /* We do not need to create a binding for this name;
751 push_overloaded_decl will have already done so if
753 need_new_binding
= 0;
755 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
757 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
759 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
760 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
763 /* If declaring a type as a typedef, copy the type (unless we're
764 at line 0), and install this TYPE_DECL as the new type's typedef
765 name. See the extensive comment in ../c-decl.c (pushdecl). */
766 if (TREE_CODE (x
) == TYPE_DECL
)
768 tree type
= TREE_TYPE (x
);
769 if (DECL_IS_BUILTIN (x
))
771 if (TYPE_NAME (type
) == 0)
772 TYPE_NAME (type
) = x
;
774 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
775 /* We don't want to copy the type when all we're
776 doing is making a TYPE_DECL for the purposes of
778 && (!TYPE_NAME (type
)
779 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
781 DECL_ORIGINAL_TYPE (x
) = type
;
782 type
= build_variant_type_copy (type
);
783 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
784 TYPE_NAME (type
) = x
;
785 TREE_TYPE (x
) = type
;
788 if (type
!= error_mark_node
790 && TYPE_IDENTIFIER (type
))
791 set_identifier_type_value (DECL_NAME (x
), x
);
794 /* Multiple external decls of the same identifier ought to match.
796 We get warnings about inline functions where they are defined.
797 We get warnings about other functions from push_overloaded_decl.
799 Avoid duplicate warnings where they are used. */
800 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
804 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
805 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
806 decl
= OVL_FUNCTION (decl
);
808 if (decl
&& decl
!= error_mark_node
809 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
810 /* If different sort of thing, we already gave an error. */
811 && TREE_CODE (decl
) == TREE_CODE (x
)
812 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
814 pedwarn ("type mismatch with previous external decl of %q#D", x
);
815 cp_pedwarn_at ("previous external decl of %q#D", decl
);
819 /* This name is new in its binding level.
820 Install the new declaration and return it. */
821 if (namespace_bindings_p ())
823 /* Install a global value. */
825 /* If the first global decl has external linkage,
826 warn if we later see static one. */
827 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
828 TREE_PUBLIC (name
) = 1;
830 /* Bind the name for the entity. */
831 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
833 && (TREE_CODE (x
) == TYPE_DECL
834 || TREE_CODE (x
) == VAR_DECL
835 || TREE_CODE (x
) == ALIAS_DECL
836 || TREE_CODE (x
) == NAMESPACE_DECL
837 || TREE_CODE (x
) == CONST_DECL
838 || TREE_CODE (x
) == TEMPLATE_DECL
))
839 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
841 /* If new decl is `static' and an `extern' was seen previously,
843 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
844 warn_extern_redeclared_static (x
, t
);
848 /* Here to install a non-global value. */
849 tree oldlocal
= innermost_non_namespace_value (name
);
850 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
852 if (need_new_binding
)
854 push_local_binding (name
, x
, 0);
855 /* Because push_local_binding will hook X on to the
856 current_binding_level's name list, we don't want to
857 do that again below. */
858 need_new_binding
= 0;
861 /* If this is a TYPE_DECL, push it into the type value slot. */
862 if (TREE_CODE (x
) == TYPE_DECL
)
863 set_identifier_type_value (name
, x
);
865 /* Clear out any TYPE_DECL shadowed by a namespace so that
866 we won't think this is a type. The C struct hack doesn't
867 go through namespaces. */
868 if (TREE_CODE (x
) == NAMESPACE_DECL
)
869 set_identifier_type_value (name
, NULL_TREE
);
876 && TREE_CODE (oldlocal
) == VAR_DECL
877 && DECL_DEAD_FOR_LOCAL (oldlocal
))
878 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
880 if (oldlocal
== NULL_TREE
)
881 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
884 /* If this is an extern function declaration, see if we
885 have a global definition or declaration for the function. */
886 if (oldlocal
== NULL_TREE
888 && oldglobal
!= NULL_TREE
889 && TREE_CODE (x
) == FUNCTION_DECL
890 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
892 /* We have one. Their types must agree. */
893 if (decls_match (x
, oldglobal
))
897 warning ("extern declaration of %q#D doesn't match", x
);
898 cp_warning_at ("global declaration %q#D", oldglobal
);
901 /* If we have a local external declaration,
902 and no file-scope declaration has yet been seen,
903 then if we later have a file-scope decl it must not be static. */
904 if (oldlocal
== NULL_TREE
905 && oldglobal
== NULL_TREE
908 TREE_PUBLIC (name
) = 1;
910 /* Warn if shadowing an argument at the top level of the body. */
911 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
912 /* Inline decls shadow nothing. */
913 && !DECL_FROM_INLINE (x
)
914 && TREE_CODE (oldlocal
) == PARM_DECL
915 /* Don't check the `this' parameter. */
916 && !DECL_ARTIFICIAL (oldlocal
))
920 /* Don't complain if it's from an enclosing function. */
921 if (DECL_CONTEXT (oldlocal
) == current_function_decl
922 && TREE_CODE (x
) != PARM_DECL
)
924 /* Go to where the parms should be and see if we find
926 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
928 /* Skip the ctor/dtor cleanup level. */
932 if (b
->kind
== sk_function_parms
)
934 error ("declaration of %q#D shadows a parameter", x
);
939 if (warn_shadow
&& !err
)
941 warning ("declaration of %q#D shadows a parameter", x
);
942 warning ("%Jshadowed declaration is here", oldlocal
);
946 /* Maybe warn if shadowing something else. */
947 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
948 /* No shadow warnings for internally generated vars. */
949 && ! DECL_ARTIFICIAL (x
)
950 /* No shadow warnings for vars made for inlining. */
951 && ! DECL_FROM_INLINE (x
))
955 if (current_class_ptr
)
956 member
= lookup_member (current_class_type
,
959 /*want_type=*/false);
963 if (member
&& !TREE_STATIC (member
))
965 /* Location of previous decl is not useful in this case. */
966 warning ("declaration of %qD shadows a member of 'this'",
969 else if (oldlocal
!= NULL_TREE
970 && TREE_CODE (oldlocal
) == VAR_DECL
)
972 warning ("declaration of %qD shadows a previous local", x
);
973 warning ("%Jshadowed declaration is here", oldlocal
);
975 else if (oldglobal
!= NULL_TREE
976 && TREE_CODE (oldglobal
) == VAR_DECL
)
977 /* XXX shadow warnings in outer-more namespaces */
979 warning ("declaration of %qD shadows a global declaration",
981 warning ("%Jshadowed declaration is here", oldglobal
);
986 if (TREE_CODE (x
) == FUNCTION_DECL
)
987 check_default_args (x
);
989 if (TREE_CODE (x
) == VAR_DECL
)
990 maybe_register_incomplete_var (x
);
993 if (need_new_binding
)
994 add_decl_to_level (x
,
995 DECL_NAMESPACE_SCOPE_P (x
)
996 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
997 : current_binding_level
);
999 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1002 /* Enter DECL into the symbol table, if that's appropriate. Returns
1003 DECL, or a modified version thereof. */
1006 maybe_push_decl (tree decl
)
1008 tree type
= TREE_TYPE (decl
);
1010 /* Add this decl to the current binding level, but not if it comes
1011 from another scope, e.g. a static member variable. TEM may equal
1012 DECL or it may be a previous decl of the same name. */
1013 if (decl
== error_mark_node
1014 || (TREE_CODE (decl
) != PARM_DECL
1015 && DECL_CONTEXT (decl
) != NULL_TREE
1016 /* Definitions of namespace members outside their namespace are
1018 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
1019 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1020 || TREE_CODE (type
) == UNKNOWN_TYPE
1021 /* The declaration of a template specialization does not affect
1022 the functions available for overload resolution, so we do not
1024 || (TREE_CODE (decl
) == FUNCTION_DECL
1025 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1028 return pushdecl (decl
);
1031 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1032 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1033 doesn't really belong to this binding level, that it got here
1034 through a using-declaration. */
1037 push_local_binding (tree id
, tree decl
, int flags
)
1039 struct cp_binding_level
*b
;
1041 /* Skip over any local classes. This makes sense if we call
1042 push_local_binding with a friend decl of a local class. */
1043 b
= innermost_nonclass_level ();
1045 if (lookup_name_innermost_nonclass_level (id
))
1047 /* Supplement the existing binding. */
1048 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1049 /* It didn't work. Something else must be bound at this
1050 level. Do not add DECL to the list of things to pop
1055 /* Create a new binding. */
1056 push_binding (id
, decl
, b
);
1058 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1059 /* We must put the OVERLOAD into a TREE_LIST since the
1060 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1061 decls that got here through a using-declaration. */
1062 decl
= build_tree_list (NULL_TREE
, decl
);
1064 /* And put DECL on the list of things declared by the current
1066 add_decl_to_level (decl
, b
);
1069 /* Check to see whether or not DECL is a variable that would have been
1070 in scope under the ARM, but is not in scope under the ANSI/ISO
1071 standard. If so, issue an error message. If name lookup would
1072 work in both cases, but return a different result, this function
1073 returns the result of ANSI/ISO lookup. Otherwise, it returns
1077 check_for_out_of_scope_variable (tree decl
)
1081 /* We only care about out of scope variables. */
1082 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1085 shadowed
= DECL_SHADOWED_FOR_VAR (decl
);
1086 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1087 && DECL_DEAD_FOR_LOCAL (shadowed
))
1088 shadowed
= DECL_SHADOWED_FOR_VAR (shadowed
);
1090 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1093 if (!DECL_ERROR_REPORTED (decl
))
1095 warning ("name lookup of %qD changed", DECL_NAME (decl
));
1096 cp_warning_at (" matches this %qD under ISO standard rules",
1098 cp_warning_at (" matches this %qD under old rules", decl
);
1099 DECL_ERROR_REPORTED (decl
) = 1;
1104 /* If we have already complained about this declaration, there's no
1105 need to do it again. */
1106 if (DECL_ERROR_REPORTED (decl
))
1109 DECL_ERROR_REPORTED (decl
) = 1;
1111 if (TREE_TYPE (decl
) == error_mark_node
)
1114 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1116 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1118 cp_error_at (" cannot use obsolete binding at %qD because "
1119 "it has a destructor", decl
);
1120 return error_mark_node
;
1124 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1126 cp_pedwarn_at (" using obsolete binding at %qD", decl
);
1132 /* true means unconditionally make a BLOCK for the next level pushed. */
1134 static bool keep_next_level_flag
;
1136 static int binding_depth
= 0;
1137 static int is_class_level
= 0;
1144 for (i
= 0; i
< depth
* 2; i
++)
1148 /* Return a string describing the kind of SCOPE we have. */
1150 cxx_scope_descriptor (cxx_scope
*scope
)
1152 /* The order of this table must match the "scope_kind"
1154 static const char* scope_kind_names
[] = {
1160 "function-parameter-scope",
1163 "template-parameter-scope",
1164 "template-explicit-spec-scope"
1166 const scope_kind kind
= scope
->explicit_spec_p
1167 ? sk_template_spec
: scope
->kind
;
1169 return scope_kind_names
[kind
];
1172 /* Output a debugging information about SCOPE when performing
1175 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1177 const char *desc
= cxx_scope_descriptor (scope
);
1178 if (scope
->this_entity
)
1179 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1180 scope
->this_entity
, (void *) scope
, line
);
1182 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1185 /* Return the estimated initial size of the hashtable of a NAMESPACE
1188 static inline size_t
1189 namespace_scope_ht_size (tree ns
)
1191 tree name
= DECL_NAME (ns
);
1193 return name
== std_identifier
1194 ? NAMESPACE_STD_HT_SIZE
1195 : (name
== global_scope_name
1196 ? GLOBAL_SCOPE_HT_SIZE
1197 : NAMESPACE_ORDINARY_HT_SIZE
);
1200 /* A chain of binding_level structures awaiting reuse. */
1202 static GTY((deletable
)) struct cp_binding_level
*free_binding_level
;
1204 /* Insert SCOPE as the innermost binding level. */
1207 push_binding_level (struct cp_binding_level
*scope
)
1209 /* Add it to the front of currently active scopes stack. */
1210 scope
->level_chain
= current_binding_level
;
1211 current_binding_level
= scope
;
1212 keep_next_level_flag
= false;
1214 if (ENABLE_SCOPE_CHECKING
)
1216 scope
->binding_depth
= binding_depth
;
1217 indent (binding_depth
);
1218 cxx_scope_debug (scope
, input_line
, "push");
1224 /* Create a new KIND scope and make it the top of the active scopes stack.
1225 ENTITY is the scope of the associated C++ entity (namespace, class,
1226 function); it is NULL otherwise. */
1229 begin_scope (scope_kind kind
, tree entity
)
1233 /* Reuse or create a struct for this binding level. */
1234 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1236 scope
= free_binding_level
;
1237 free_binding_level
= scope
->level_chain
;
1240 scope
= GGC_NEW (cxx_scope
);
1241 memset (scope
, 0, sizeof (cxx_scope
));
1243 scope
->this_entity
= entity
;
1244 scope
->more_cleanups_ok
= true;
1251 case sk_template_spec
:
1252 scope
->explicit_spec_p
= true;
1253 kind
= sk_template_parms
;
1255 case sk_template_parms
:
1261 case sk_function_parms
:
1262 scope
->keep
= keep_next_level_flag
;
1266 NAMESPACE_LEVEL (entity
) = scope
;
1267 VARRAY_TREE_INIT (scope
->static_decls
,
1268 DECL_NAME (entity
) == std_identifier
1269 || DECL_NAME (entity
) == global_scope_name
1271 "Static declarations");
1275 /* Should not happen. */
1281 push_binding_level (scope
);
1286 /* We're about to leave current scope. Pop the top of the stack of
1287 currently active scopes. Return the enclosing scope, now active. */
1292 cxx_scope
*scope
= current_binding_level
;
1294 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1295 current_binding_level
= class_binding_level
;
1297 /* We cannot leave a scope, if there are none left. */
1298 if (NAMESPACE_LEVEL (global_namespace
))
1299 gcc_assert (!global_scope_p (scope
));
1301 if (ENABLE_SCOPE_CHECKING
)
1303 indent (--binding_depth
);
1304 cxx_scope_debug (scope
, input_line
, "leave");
1305 if (is_class_level
!= (scope
== class_binding_level
))
1307 indent (binding_depth
);
1308 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1313 /* Move one nesting level up. */
1314 current_binding_level
= scope
->level_chain
;
1316 /* Namespace-scopes are left most probably temporarily, not
1317 completely; they can be reopen later, e.g. in namespace-extension
1318 or any name binding activity that requires us to resume a
1319 namespace. For classes, we cache some binding levels. For other
1320 scopes, we just make the structure available for reuse. */
1321 if (scope
->kind
!= sk_namespace
1322 && scope
->kind
!= sk_class
)
1324 scope
->level_chain
= free_binding_level
;
1325 gcc_assert (!ENABLE_SCOPE_CHECKING
1326 || scope
->binding_depth
== binding_depth
);
1327 free_binding_level
= scope
;
1330 /* Find the innermost enclosing class scope, and reset
1331 CLASS_BINDING_LEVEL appropriately. */
1332 if (scope
->kind
== sk_class
)
1334 class_binding_level
= NULL
;
1335 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1336 if (scope
->kind
== sk_class
)
1338 class_binding_level
= scope
;
1343 return current_binding_level
;
1347 resume_scope (struct cp_binding_level
* b
)
1349 /* Resuming binding levels is meant only for namespaces,
1350 and those cannot nest into classes. */
1351 gcc_assert (!class_binding_level
);
1352 /* Also, resuming a non-directly nested namespace is a no-no. */
1353 gcc_assert (b
->level_chain
== current_binding_level
);
1354 current_binding_level
= b
;
1355 if (ENABLE_SCOPE_CHECKING
)
1357 b
->binding_depth
= binding_depth
;
1358 indent (binding_depth
);
1359 cxx_scope_debug (b
, input_line
, "resume");
1365 /* Return the innermost binding level that is not for a class scope. */
1368 innermost_nonclass_level (void)
1372 b
= current_binding_level
;
1373 while (b
->kind
== sk_class
)
1379 /* We're defining an object of type TYPE. If it needs a cleanup, but
1380 we're not allowed to add any more objects with cleanups to the current
1381 scope, create a new binding level. */
1384 maybe_push_cleanup_level (tree type
)
1386 if (type
!= error_mark_node
1387 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1388 && current_binding_level
->more_cleanups_ok
== 0)
1390 begin_scope (sk_cleanup
, NULL
);
1391 current_binding_level
->statement_list
= push_stmt_list ();
1395 /* Nonzero if we are currently in the global binding level. */
1398 global_bindings_p (void)
1400 return global_scope_p (current_binding_level
);
1403 /* True if we are currently in a toplevel binding level. This
1404 means either the global binding level or a namespace in a toplevel
1405 binding level. Since there are no non-toplevel namespace levels,
1406 this really means any namespace or template parameter level. We
1407 also include a class whose context is toplevel. */
1410 toplevel_bindings_p (void)
1412 struct cp_binding_level
*b
= innermost_nonclass_level ();
1414 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1417 /* True if this is a namespace scope, or if we are defining a class
1418 which is itself at namespace scope, or whose enclosing class is
1419 such a class, etc. */
1422 namespace_bindings_p (void)
1424 struct cp_binding_level
*b
= innermost_nonclass_level ();
1426 return b
->kind
== sk_namespace
;
1429 /* True if the current level needs to have a BLOCK made. */
1434 return (current_binding_level
->blocks
!= NULL_TREE
1435 || current_binding_level
->keep
1436 || current_binding_level
->kind
== sk_cleanup
1437 || current_binding_level
->names
!= NULL_TREE
);
1440 /* Returns the kind of the innermost scope. */
1443 innermost_scope_kind (void)
1445 return current_binding_level
->kind
;
1448 /* Returns true if this scope was created to store template parameters. */
1451 template_parm_scope_p (void)
1453 return innermost_scope_kind () == sk_template_parms
;
1456 /* If KEEP is true, make a BLOCK node for the next binding level,
1457 unconditionally. Otherwise, use the normal logic to decide whether
1458 or not to create a BLOCK. */
1461 keep_next_level (bool keep
)
1463 keep_next_level_flag
= keep
;
1466 /* Return the list of declarations of the current level.
1467 Note that this list is in reverse order unless/until
1468 you nreverse it; and when you do nreverse it, you must
1469 store the result back using `storedecls' or you will lose. */
1474 return current_binding_level
->names
;
1477 /* For debugging. */
1478 static int no_print_functions
= 0;
1479 static int no_print_builtins
= 0;
1482 print_binding_level (struct cp_binding_level
* lvl
)
1486 fprintf (stderr
, " blocks=" HOST_PTR_PRINTF
, (void *) lvl
->blocks
);
1487 if (lvl
->more_cleanups_ok
)
1488 fprintf (stderr
, " more-cleanups-ok");
1489 if (lvl
->have_cleanups
)
1490 fprintf (stderr
, " have-cleanups");
1491 fprintf (stderr
, "\n");
1494 fprintf (stderr
, " names:\t");
1495 /* We can probably fit 3 names to a line? */
1496 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1498 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1500 if (no_print_builtins
1501 && (TREE_CODE (t
) == TYPE_DECL
)
1502 && DECL_IS_BUILTIN (t
))
1505 /* Function decls tend to have longer names. */
1506 if (TREE_CODE (t
) == FUNCTION_DECL
)
1513 fprintf (stderr
, "\n\t");
1516 print_node_brief (stderr
, "", t
, 0);
1517 if (t
== error_mark_node
)
1521 fprintf (stderr
, "\n");
1523 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1526 cp_class_binding
*b
;
1527 fprintf (stderr
, " class-shadowed:");
1529 VEC_iterate(cp_class_binding
, lvl
->class_shadowed
, i
, b
);
1531 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1532 fprintf (stderr
, "\n");
1534 if (lvl
->type_shadowed
)
1536 fprintf (stderr
, " type-shadowed:");
1537 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1539 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1541 fprintf (stderr
, "\n");
1546 print_other_binding_stack (struct cp_binding_level
*stack
)
1548 struct cp_binding_level
*level
;
1549 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1551 fprintf (stderr
, "binding level " HOST_PTR_PRINTF
"\n", (void *) level
);
1552 print_binding_level (level
);
1557 print_binding_stack (void)
1559 struct cp_binding_level
*b
;
1560 fprintf (stderr
, "current_binding_level=" HOST_PTR_PRINTF
1561 "\nclass_binding_level=" HOST_PTR_PRINTF
1562 "\nNAMESPACE_LEVEL (global_namespace)=" HOST_PTR_PRINTF
"\n",
1563 (void *) current_binding_level
, (void *) class_binding_level
,
1564 (void *) NAMESPACE_LEVEL (global_namespace
));
1565 if (class_binding_level
)
1567 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1568 if (b
== current_binding_level
)
1571 b
= class_binding_level
;
1573 b
= current_binding_level
;
1576 b
= current_binding_level
;
1577 print_other_binding_stack (b
);
1578 fprintf (stderr
, "global:\n");
1579 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1582 /* Return the type associated with id. */
1585 identifier_type_value (tree id
)
1587 timevar_push (TV_NAME_LOOKUP
);
1588 /* There is no type with that name, anywhere. */
1589 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1590 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1591 /* This is not the type marker, but the real thing. */
1592 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1593 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, REAL_IDENTIFIER_TYPE_VALUE (id
));
1594 /* Have to search for it. It must be on the global level, now.
1595 Ask lookup_name not to return non-types. */
1596 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
1598 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, TREE_TYPE (id
));
1599 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1602 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1603 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1606 identifier_global_value (tree t
)
1608 return IDENTIFIER_GLOBAL_VALUE (t
);
1611 /* Push a definition of struct, union or enum tag named ID. into
1612 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1613 the tag ID is not already defined. */
1616 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1620 if (b
->kind
!= sk_namespace
)
1622 /* Shadow the marker, not the real thing, so that the marker
1623 gets restored later. */
1624 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1626 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1627 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1628 TREE_TYPE (b
->type_shadowed
) = type
;
1632 cxx_binding
*binding
=
1633 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1636 supplement_binding (binding
, decl
);
1638 binding
->value
= decl
;
1640 /* Store marker instead of real type. */
1641 type
= global_type_node
;
1643 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1646 /* As set_identifier_type_value_with_scope, but using
1647 current_binding_level. */
1650 set_identifier_type_value (tree id
, tree decl
)
1652 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1655 /* Return the name for the constructor (or destructor) for the
1656 specified class TYPE. When given a template, this routine doesn't
1657 lose the specialization. */
1660 constructor_name_full (tree type
)
1662 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1665 /* Return the name for the constructor (or destructor) for the
1666 specified class. When given a template, return the plain
1667 unspecialized name. */
1670 constructor_name (tree type
)
1673 name
= constructor_name_full (type
);
1674 if (IDENTIFIER_TEMPLATE (name
))
1675 name
= IDENTIFIER_TEMPLATE (name
);
1679 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1682 constructor_name_p (tree name
, tree type
)
1689 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1692 ctor_name
= constructor_name_full (type
);
1693 if (name
== ctor_name
)
1695 if (IDENTIFIER_TEMPLATE (ctor_name
)
1696 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1701 /* Counter used to create anonymous type names. */
1703 static GTY(()) int anon_cnt
;
1705 /* Return an IDENTIFIER which can be used as a name for
1706 anonymous structs and unions. */
1709 make_anon_name (void)
1713 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1714 return get_identifier (buf
);
1717 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1719 static inline cxx_binding
*
1720 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1722 timevar_push (TV_NAME_LOOKUP
);
1724 for (; binding
!= NULL
; binding
= binding
->previous
)
1725 if (binding
->scope
== scope
)
1726 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
);
1728 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, (cxx_binding
*)0);
1731 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1733 static inline cxx_binding
*
1734 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1736 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1739 /* Fold-in case where NAME is used only once. */
1740 if (scope
== b
->scope
&& b
->previous
== NULL
)
1742 return find_binding (scope
, b
);
1747 /* Always returns a binding for name in scope. If no binding is
1748 found, make a new one. */
1750 static cxx_binding
*
1751 binding_for_name (cxx_scope
*scope
, tree name
)
1753 cxx_binding
*result
;
1755 result
= cxx_scope_find_binding_for_name (scope
, name
);
1758 /* Not found, make a new one. */
1759 result
= cxx_binding_make (NULL
, NULL
);
1760 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1761 result
->scope
= scope
;
1762 result
->is_local
= false;
1763 result
->value_is_inherited
= false;
1764 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1768 /* Insert another USING_DECL into the current binding level, returning
1769 this declaration. If this is a redeclaration, do nothing, and
1770 return NULL_TREE if this not in namespace scope (in namespace
1771 scope, a using decl might extend any previous bindings). */
1774 push_using_decl (tree scope
, tree name
)
1778 timevar_push (TV_NAME_LOOKUP
);
1779 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
1780 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1781 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
1782 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
1785 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
1786 namespace_bindings_p () ? decl
: NULL_TREE
);
1787 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
1788 DECL_INITIAL (decl
) = scope
;
1789 TREE_CHAIN (decl
) = current_binding_level
->usings
;
1790 current_binding_level
->usings
= decl
;
1791 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1794 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1795 caller to set DECL_CONTEXT properly. */
1798 pushdecl_with_scope (tree x
, cxx_scope
*level
)
1800 struct cp_binding_level
*b
;
1801 tree function_decl
= current_function_decl
;
1803 timevar_push (TV_NAME_LOOKUP
);
1804 current_function_decl
= NULL_TREE
;
1805 if (level
->kind
== sk_class
)
1807 b
= class_binding_level
;
1808 class_binding_level
= level
;
1809 pushdecl_class_level (x
);
1810 class_binding_level
= b
;
1814 b
= current_binding_level
;
1815 current_binding_level
= level
;
1817 current_binding_level
= b
;
1819 current_function_decl
= function_decl
;
1820 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1823 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1824 other definitions already in place. We get around this by making
1825 the value of the identifier point to a list of all the things that
1826 want to be referenced by that name. It is then up to the users of
1827 that name to decide what to do with that list.
1829 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1830 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1832 FLAGS is a bitwise-or of the following values:
1833 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1835 PUSH_USING: DECL is being pushed as the result of a using
1838 The value returned may be a previous declaration if we guessed wrong
1839 about what language DECL should belong to (C or C++). Otherwise,
1840 it's always DECL (and never something that's not a _DECL). */
1843 push_overloaded_decl (tree decl
, int flags
)
1845 tree name
= DECL_NAME (decl
);
1848 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
1850 timevar_push (TV_NAME_LOOKUP
);
1852 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
1854 old
= lookup_name_innermost_nonclass_level (name
);
1858 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
1860 tree t
= TREE_TYPE (old
);
1861 if (IS_AGGR_TYPE (t
) && warn_shadow
1862 && (! DECL_IN_SYSTEM_HEADER (decl
)
1863 || ! DECL_IN_SYSTEM_HEADER (old
)))
1864 warning ("%q#D hides constructor for %q#T", decl
, t
);
1867 else if (is_overloaded_fn (old
))
1871 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
1873 tree fn
= OVL_CURRENT (tmp
);
1875 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
1876 && !(flags
& PUSH_USING
)
1877 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1878 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
1879 && ! decls_match (fn
, decl
))
1880 error ("%q#D conflicts with previous using declaration %q#D",
1883 if (duplicate_decls (decl
, fn
) == fn
)
1884 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, fn
);
1887 /* We don't overload implicit built-ins. duplicate_decls()
1888 may fail to merge the decls if the new decl is e.g. a
1889 template function. */
1890 if (TREE_CODE (old
) == FUNCTION_DECL
1891 && DECL_ANTICIPATED (old
))
1894 else if (old
== error_mark_node
)
1895 /* Ignore the undefined symbol marker. */
1899 cp_error_at ("previous non-function declaration %q#D", old
);
1900 error ("conflicts with function declaration %q#D", decl
);
1901 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1905 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
1906 /* If it's a using declaration, we always need to build an OVERLOAD,
1907 because it's the only way to remember that the declaration comes
1908 from 'using', and have the lookup behave correctly. */
1909 || (flags
& PUSH_USING
))
1911 if (old
&& TREE_CODE (old
) != OVERLOAD
)
1912 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
1914 new_binding
= ovl_cons (decl
, old
);
1915 if (flags
& PUSH_USING
)
1916 OVL_USED (new_binding
) = 1;
1919 /* NAME is not ambiguous. */
1923 set_namespace_binding (name
, current_namespace
, new_binding
);
1926 /* We only create an OVERLOAD if there was a previous binding at
1927 this level, or if decl is a template. In the former case, we
1928 need to remove the old binding and replace it with the new
1929 binding. We must also run through the NAMES on the binding
1930 level where the name was bound to update the chain. */
1932 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
1936 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
1938 d
= &TREE_CHAIN (*d
))
1940 || (TREE_CODE (*d
) == TREE_LIST
1941 && TREE_VALUE (*d
) == old
))
1943 if (TREE_CODE (*d
) == TREE_LIST
)
1944 /* Just replace the old binding with the new. */
1945 TREE_VALUE (*d
) = new_binding
;
1947 /* Build a TREE_LIST to wrap the OVERLOAD. */
1948 *d
= tree_cons (NULL_TREE
, new_binding
,
1951 /* And update the cxx_binding node. */
1952 IDENTIFIER_BINDING (name
)->value
= new_binding
;
1953 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1956 /* We should always find a previous binding in this case. */
1960 /* Install the new binding. */
1961 push_local_binding (name
, new_binding
, flags
);
1964 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1967 /* Check a non-member using-declaration. Return the name and scope
1968 being used, and the USING_DECL, or NULL_TREE on failure. */
1971 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
1973 /* [namespace.udecl]
1974 A using-declaration for a class member shall be a
1975 member-declaration. */
1978 error ("%qT is not a namespace", scope
);
1981 else if (scope
== error_mark_node
)
1984 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
1987 A using-declaration shall not name a template-id. */
1988 error ("a using-declaration cannot specify a template-id. "
1989 "Try %<using %D%>", name
);
1993 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
1995 error ("namespace %qD not allowed in using-declaration", decl
);
1999 if (TREE_CODE (decl
) == SCOPE_REF
)
2001 /* It's a nested name with template parameter dependent scope.
2002 This can only be using-declaration for class member. */
2003 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2007 if (is_overloaded_fn (decl
))
2008 decl
= get_first_fn (decl
);
2010 gcc_assert (DECL_P (decl
));
2012 /* Make a USING_DECL. */
2013 return push_using_decl (scope
, name
);
2016 /* Process local and global using-declarations. */
2019 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2020 tree
*newval
, tree
*newtype
)
2022 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2024 *newval
= *newtype
= NULL_TREE
;
2025 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2029 if (!decls
.value
&& !decls
.type
)
2031 error ("%qD not declared", name
);
2035 /* Check for using functions. */
2036 if (decls
.value
&& is_overloaded_fn (decls
.value
))
2040 if (oldval
&& !is_overloaded_fn (oldval
))
2042 if (!DECL_IMPLICIT_TYPEDEF_P (oldval
))
2043 error ("%qD is already declared in this scope", name
);
2047 /* It is impossible to overload a built-in function; any
2048 explicit declaration eliminates the built-in declaration.
2049 So, if OLDVAL is a built-in, then we can just pretend it
2052 && TREE_CODE (oldval
) == FUNCTION_DECL
2053 && DECL_ANTICIPATED (oldval
))
2057 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2059 tree new_fn
= OVL_CURRENT (tmp
);
2061 /* [namespace.udecl]
2063 If a function declaration in namespace scope or block
2064 scope has the same name and the same parameter types as a
2065 function introduced by a using declaration the program is
2067 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2069 tree old_fn
= OVL_CURRENT (tmp1
);
2071 if (new_fn
== old_fn
)
2072 /* The function already exists in the current namespace. */
2074 else if (OVL_USED (tmp1
))
2075 continue; /* this is a using decl */
2076 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2077 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2079 gcc_assert (!DECL_ANTICIPATED (old_fn
));
2081 /* There was already a non-using declaration in
2082 this scope with the same parameter types. If both
2083 are the same extern "C" functions, that's ok. */
2084 if (decls_match (new_fn
, old_fn
))
2088 error ("%qD is already declared in this scope", name
);
2094 /* If we broke out of the loop, there's no reason to add
2095 this function to the using declarations for this
2100 /* If we are adding to an existing OVERLOAD, then we no
2101 longer know the type of the set of functions. */
2102 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2103 TREE_TYPE (*newval
) = unknown_type_node
;
2104 /* Add this new function to the set. */
2105 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2106 /* If there is only one function, then we use its type. (A
2107 using-declaration naming a single function can be used in
2108 contexts where overload resolution cannot be
2110 if (TREE_CODE (*newval
) != OVERLOAD
)
2112 *newval
= ovl_cons (*newval
, NULL_TREE
);
2113 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2115 OVL_USED (*newval
) = 1;
2120 *newval
= decls
.value
;
2121 if (oldval
&& !decls_match (*newval
, oldval
))
2122 error ("%qD is already declared in this scope", name
);
2125 *newtype
= decls
.type
;
2126 if (oldtype
&& *newtype
&& !same_type_p (oldtype
, *newtype
))
2128 error ("using declaration %qD introduced ambiguous type %qT",
2134 /* Process a using-declaration at function scope. */
2137 do_local_using_decl (tree decl
, tree scope
, tree name
)
2139 tree oldval
, oldtype
, newval
, newtype
;
2140 tree orig_decl
= decl
;
2142 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2143 if (decl
== NULL_TREE
)
2146 if (building_stmt_tree ()
2147 && at_function_scope_p ())
2148 add_decl_expr (decl
);
2150 oldval
= lookup_name_innermost_nonclass_level (name
);
2151 oldtype
= lookup_type_current_level (name
);
2153 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2157 if (is_overloaded_fn (newval
))
2161 /* We only need to push declarations for those functions
2162 that were not already bound in the current level.
2163 The old value might be NULL_TREE, it might be a single
2164 function, or an OVERLOAD. */
2165 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2166 term
= OVL_FUNCTION (oldval
);
2169 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2171 push_overloaded_decl (OVL_CURRENT (fn
),
2172 PUSH_LOCAL
| PUSH_USING
);
2175 push_local_binding (name
, newval
, PUSH_USING
);
2179 push_local_binding (name
, newtype
, PUSH_USING
);
2180 set_identifier_type_value (name
, newtype
);
2183 /* Emit debug info. */
2184 if (!processing_template_decl
)
2185 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2188 /* Returns true if ROOT (a namespace, class, or function) encloses
2189 CHILD. CHILD may be either a class type or a namespace. */
2192 is_ancestor (tree root
, tree child
)
2194 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2195 || TREE_CODE (root
) == FUNCTION_DECL
2196 || CLASS_TYPE_P (root
)));
2197 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2198 || CLASS_TYPE_P (child
)));
2200 /* The global namespace encloses everything. */
2201 if (root
== global_namespace
)
2206 /* If we've run out of scopes, stop. */
2209 /* If we've reached the ROOT, it encloses CHILD. */
2212 /* Go out one level. */
2214 child
= TYPE_NAME (child
);
2215 child
= DECL_CONTEXT (child
);
2219 /* Enter the class or namespace scope indicated by T suitable for name
2220 lookup. T can be arbitrary scope, not necessary nested inside the
2221 current scope. Returns a non-null scope to pop iff pop_scope
2222 should be called later to exit this scope. */
2227 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2228 push_decl_namespace (t
);
2229 else if (CLASS_TYPE_P (t
))
2231 if (!at_class_scope_p ()
2232 || !same_type_p (current_class_type
, t
))
2233 push_nested_class (t
);
2235 /* T is the same as the current scope. There is therefore no
2236 need to re-enter the scope. Since we are not actually
2237 pushing a new scope, our caller should not call
2245 /* Leave scope pushed by push_scope. */
2250 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2251 pop_decl_namespace ();
2252 else if CLASS_TYPE_P (t
)
2253 pop_nested_class ();
2256 /* Subroutine of push_inner_scope. */
2259 push_inner_scope_r (tree outer
, tree inner
)
2264 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2267 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2269 push_inner_scope_r (outer
, prev
);
2270 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2272 struct cp_binding_level
*save_template_parm
= 0;
2273 /* Temporary take out template parameter scopes. They are saved
2274 in reversed order in save_template_parm. */
2275 while (current_binding_level
->kind
== sk_template_parms
)
2277 struct cp_binding_level
*b
= current_binding_level
;
2278 current_binding_level
= b
->level_chain
;
2279 b
->level_chain
= save_template_parm
;
2280 save_template_parm
= b
;
2283 resume_scope (NAMESPACE_LEVEL (inner
));
2284 current_namespace
= inner
;
2286 /* Restore template parameter scopes. */
2287 while (save_template_parm
)
2289 struct cp_binding_level
*b
= save_template_parm
;
2290 save_template_parm
= b
->level_chain
;
2291 b
->level_chain
= current_binding_level
;
2292 current_binding_level
= b
;
2299 /* Enter the scope INNER from current scope. INNER must be a scope
2300 nested inside current scope. This works with both name lookup and
2301 pushing name into scope. In case a template parameter scope is present,
2302 namespace is pushed under the template parameter scope according to
2303 name lookup rule in 14.6.1/6.
2305 Return the former current scope suitable for pop_inner_scope. */
2308 push_inner_scope (tree inner
)
2310 tree outer
= current_scope ();
2312 outer
= current_namespace
;
2314 push_inner_scope_r (outer
, inner
);
2318 /* Exit the current scope INNER back to scope OUTER. */
2321 pop_inner_scope (tree outer
, tree inner
)
2324 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2327 while (outer
!= inner
)
2329 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2331 struct cp_binding_level
*save_template_parm
= 0;
2332 /* Temporary take out template parameter scopes. They are saved
2333 in reversed order in save_template_parm. */
2334 while (current_binding_level
->kind
== sk_template_parms
)
2336 struct cp_binding_level
*b
= current_binding_level
;
2337 current_binding_level
= b
->level_chain
;
2338 b
->level_chain
= save_template_parm
;
2339 save_template_parm
= b
;
2344 /* Restore template parameter scopes. */
2345 while (save_template_parm
)
2347 struct cp_binding_level
*b
= save_template_parm
;
2348 save_template_parm
= b
->level_chain
;
2349 b
->level_chain
= current_binding_level
;
2350 current_binding_level
= b
;
2356 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2360 /* Do a pushlevel for class declarations. */
2363 pushlevel_class (void)
2365 if (ENABLE_SCOPE_CHECKING
)
2368 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2371 /* ...and a poplevel for class declarations. */
2374 poplevel_class (void)
2376 struct cp_binding_level
*level
= class_binding_level
;
2377 cp_class_binding
*cb
;
2381 timevar_push (TV_NAME_LOOKUP
);
2382 gcc_assert (level
!= 0);
2384 /* If we're leaving a toplevel class, cache its binding level. */
2385 if (current_class_depth
== 1)
2386 previous_class_level
= level
;
2387 for (shadowed
= level
->type_shadowed
;
2389 shadowed
= TREE_CHAIN (shadowed
))
2390 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2392 /* Remove the bindings for all of the class-level declarations. */
2393 if (level
->class_shadowed
)
2396 VEC_iterate (cp_class_binding
, level
->class_shadowed
, i
, cb
);
2398 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
.previous
;
2399 ggc_free (level
->class_shadowed
);
2400 level
->class_shadowed
= NULL
;
2403 /* Now, pop out of the binding level which we created up in the
2404 `pushlevel_class' routine. */
2405 if (ENABLE_SCOPE_CHECKING
)
2409 timevar_pop (TV_NAME_LOOKUP
);
2412 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2413 appropriate. DECL is the value to which a name has just been
2414 bound. CLASS_TYPE is the class in which the lookup occurred. */
2417 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2420 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2424 if (TREE_CODE (decl
) == OVERLOAD
)
2425 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2428 gcc_assert (DECL_P (decl
));
2429 context
= context_for_name_lookup (decl
);
2432 if (is_properly_derived_from (class_type
, context
))
2433 INHERITED_VALUE_BINDING_P (binding
) = 1;
2435 INHERITED_VALUE_BINDING_P (binding
) = 0;
2437 else if (binding
->value
== decl
)
2438 /* We only encounter a TREE_LIST when there is an ambiguity in the
2439 base classes. Such an ambiguity can be overridden by a
2440 definition in this class. */
2441 INHERITED_VALUE_BINDING_P (binding
) = 1;
2443 INHERITED_VALUE_BINDING_P (binding
) = 0;
2446 /* Make the declaration of X appear in CLASS scope. */
2449 pushdecl_class_level (tree x
)
2452 bool is_valid
= true;
2454 timevar_push (TV_NAME_LOOKUP
);
2455 /* Get the name of X. */
2456 if (TREE_CODE (x
) == OVERLOAD
)
2457 name
= DECL_NAME (get_first_fn (x
));
2459 name
= DECL_NAME (x
);
2463 is_valid
= push_class_level_binding (name
, x
);
2464 if (TREE_CODE (x
) == TYPE_DECL
)
2465 set_identifier_type_value (name
, x
);
2467 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2469 /* If X is an anonymous aggregate, all of its members are
2470 treated as if they were members of the class containing the
2471 aggregate, for naming purposes. */
2474 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= TREE_CHAIN (f
))
2476 location_t save_location
= input_location
;
2477 input_location
= DECL_SOURCE_LOCATION (f
);
2478 if (!pushdecl_class_level (f
))
2480 input_location
= save_location
;
2483 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, is_valid
);
2486 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2487 scope. If the value returned is non-NULL, and the PREVIOUS field
2488 is not set, callers must set the PREVIOUS field explicitly. */
2490 static cxx_binding
*
2491 get_class_binding (tree name
, cxx_scope
*scope
)
2496 cxx_binding
*binding
;
2498 class_type
= scope
->this_entity
;
2500 /* Get the type binding. */
2501 type_binding
= lookup_member (class_type
, name
,
2502 /*protect=*/2, /*want_type=*/true);
2503 /* Get the value binding. */
2504 value_binding
= lookup_member (class_type
, name
,
2505 /*protect=*/2, /*want_type=*/false);
2508 && (TREE_CODE (value_binding
) == TYPE_DECL
2509 || DECL_CLASS_TEMPLATE_P (value_binding
)
2510 || (TREE_CODE (value_binding
) == TREE_LIST
2511 && TREE_TYPE (value_binding
) == error_mark_node
2512 && (TREE_CODE (TREE_VALUE (value_binding
))
2514 /* We found a type binding, even when looking for a non-type
2515 binding. This means that we already processed this binding
2518 else if (value_binding
)
2520 if (TREE_CODE (value_binding
) == TREE_LIST
2521 && TREE_TYPE (value_binding
) == error_mark_node
)
2522 /* NAME is ambiguous. */
2524 else if (BASELINK_P (value_binding
))
2525 /* NAME is some overloaded functions. */
2526 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2529 /* If we found either a type binding or a value binding, create a
2530 new binding object. */
2531 if (type_binding
|| value_binding
)
2533 binding
= new_class_binding (name
,
2537 /* This is a class-scope binding, not a block-scope binding. */
2538 LOCAL_BINDING_P (binding
) = 0;
2539 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2547 /* Make the declaration(s) of X appear in CLASS scope under the name
2548 NAME. Returns true if the binding is valid. */
2551 push_class_level_binding (tree name
, tree x
)
2553 cxx_binding
*binding
;
2557 timevar_push (TV_NAME_LOOKUP
);
2558 /* The class_binding_level will be NULL if x is a template
2559 parameter name in a member template. */
2560 if (!class_binding_level
)
2561 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2563 /* Check for invalid member names. */
2564 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
2565 /* We could have been passed a tree list if this is an ambiguous
2566 declaration. If so, pull the declaration out because
2567 check_template_shadow will not handle a TREE_LIST. */
2568 if (TREE_CODE (decl
) == TREE_LIST
2569 && TREE_TYPE (decl
) == error_mark_node
)
2570 decl
= TREE_VALUE (decl
);
2572 check_template_shadow (decl
);
2576 If T is the name of a class, then each of the following shall
2577 have a name different from T:
2579 -- every static data member of class T;
2581 -- every member of class T that is itself a type;
2583 -- every enumerator of every member of class T that is an
2586 -- every member of every anonymous union that is a member of
2589 (Non-static data members were also forbidden to have the same
2590 name as T until TC1.) */
2591 if ((TREE_CODE (x
) == VAR_DECL
2592 || TREE_CODE (x
) == CONST_DECL
2593 || (TREE_CODE (x
) == TYPE_DECL
2594 && !DECL_SELF_REFERENCE_P (x
))
2595 /* A data member of an anonymous union. */
2596 || (TREE_CODE (x
) == FIELD_DECL
2597 && DECL_CONTEXT (x
) != current_class_type
))
2598 && DECL_NAME (x
) == constructor_name (current_class_type
))
2600 tree scope
= context_for_name_lookup (x
);
2601 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
2603 error ("%qD has the same name as the class in which it is "
2606 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2610 /* Get the current binding for NAME in this class, if any. */
2611 binding
= IDENTIFIER_BINDING (name
);
2612 if (!binding
|| binding
->scope
!= class_binding_level
)
2614 binding
= get_class_binding (name
, class_binding_level
);
2615 /* If a new binding was created, put it at the front of the
2616 IDENTIFIER_BINDING list. */
2619 binding
->previous
= IDENTIFIER_BINDING (name
);
2620 IDENTIFIER_BINDING (name
) = binding
;
2624 /* If there is already a binding, then we may need to update the
2626 if (binding
&& binding
->value
)
2628 tree bval
= binding
->value
;
2629 tree old_decl
= NULL_TREE
;
2631 if (INHERITED_VALUE_BINDING_P (binding
))
2633 /* If the old binding was from a base class, and was for a
2634 tag name, slide it over to make room for the new binding.
2635 The old binding is still visible if explicitly qualified
2636 with a class-key. */
2637 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2638 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2640 old_decl
= binding
->type
;
2641 binding
->type
= bval
;
2642 binding
->value
= NULL_TREE
;
2643 INHERITED_VALUE_BINDING_P (binding
) = 0;
2648 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2650 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2651 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2652 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
2654 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
2655 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2657 if (old_decl
&& binding
->scope
== class_binding_level
)
2660 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2661 here. This function is only used to register bindings
2662 from with the class definition itself. */
2663 INHERITED_VALUE_BINDING_P (binding
) = 0;
2664 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2668 /* Note that we declared this value so that we can issue an error if
2669 this is an invalid redeclaration of a name already used for some
2671 note_name_declared_in_class (name
, decl
);
2673 /* If we didn't replace an existing binding, put the binding on the
2674 stack of bindings for the identifier, and update the shadowed
2676 if (binding
&& binding
->scope
== class_binding_level
)
2677 /* Supplement the existing binding. */
2678 ok
= supplement_binding (binding
, decl
);
2681 /* Create a new binding. */
2682 push_binding (name
, decl
, class_binding_level
);
2686 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
2689 /* Process "using SCOPE::NAME" in a class scope. Return the
2690 USING_DECL created. */
2693 do_class_using_decl (tree scope
, tree name
)
2697 if (!scope
|| !TYPE_P (scope
))
2699 error ("using-declaration for non-member at class scope");
2702 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2704 error ("using-declaration cannot name destructor");
2708 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
2710 /* Dependent using decls have a NULL type, non-dependent ones have a
2712 type
= dependent_type_p (scope
) ? NULL_TREE
: void_type_node
;
2713 value
= build_lang_decl (USING_DECL
, name
, type
);
2714 DECL_INITIAL (value
) = scope
;
2716 if (scope
&& !processing_template_decl
)
2720 r
= lookup_qualified_name (scope
, name
, false, false);
2721 if (r
&& (DECL_P (r
) || TREE_CODE (r
) == OVERLOAD
))
2722 cp_emit_debug_info_for_using (r
, scope
);
2728 /* Return the binding value for name in scope. */
2731 namespace_binding (tree name
, tree scope
)
2733 cxx_binding
*binding
;
2736 scope
= global_namespace
;
2738 /* Unnecessary for the global namespace because it can't be an alias. */
2739 scope
= ORIGINAL_NAMESPACE (scope
);
2741 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2743 return binding
? binding
->value
: NULL_TREE
;
2746 /* Set the binding value for name in scope. */
2749 set_namespace_binding (tree name
, tree scope
, tree val
)
2753 timevar_push (TV_NAME_LOOKUP
);
2754 if (scope
== NULL_TREE
)
2755 scope
= global_namespace
;
2756 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2757 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
2760 supplement_binding (b
, val
);
2761 timevar_pop (TV_NAME_LOOKUP
);
2764 /* Set the context of a declaration to scope. Complain if we are not
2768 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
2772 /* Get rid of namespace aliases. */
2773 scope
= ORIGINAL_NAMESPACE (scope
);
2775 /* It is ok for friends to be qualified in parallel space. */
2776 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
2777 error ("declaration of %qD not in a namespace surrounding %qD",
2779 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
2781 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2782 if (scope
== current_namespace
)
2784 if (at_namespace_scope_p ())
2785 error ("explicit qualification in declaration of `%D'",
2790 /* See whether this has been declared in the namespace. */
2791 old
= namespace_binding (DECL_NAME (decl
), scope
);
2793 /* No old declaration at all. */
2795 /* A template can be explicitly specialized in any namespace. */
2796 if (processing_explicit_instantiation
)
2798 if (!is_overloaded_fn (decl
))
2799 /* Don't compare non-function decls with decls_match here, since
2800 it can't check for the correct constness at this
2801 point. pushdecl will find those errors later. */
2803 /* Since decl is a function, old should contain a function decl. */
2804 if (!is_overloaded_fn (old
))
2806 if (processing_template_decl
|| processing_specialization
)
2807 /* We have not yet called push_template_decl to turn a
2808 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2809 match. But, we'll check later, when we construct the
2812 if (is_overloaded_fn (old
))
2814 for (; old
; old
= OVL_NEXT (old
))
2815 if (decls_match (decl
, OVL_CURRENT (old
)))
2818 else if (decls_match (decl
, old
))
2821 error ("%qD should have been declared inside %qD", decl
, scope
);
2824 /* Return the namespace where the current declaration is declared. */
2827 current_decl_namespace (void)
2830 /* If we have been pushed into a different namespace, use it. */
2831 if (decl_namespace_list
)
2832 return TREE_PURPOSE (decl_namespace_list
);
2834 if (current_class_type
)
2835 result
= decl_namespace_context (current_class_type
);
2836 else if (current_function_decl
)
2837 result
= decl_namespace_context (current_function_decl
);
2839 result
= current_namespace
;
2843 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2844 select a name that is unique to this compilation unit. */
2847 push_namespace (tree name
)
2851 int implicit_use
= 0;
2854 timevar_push (TV_NAME_LOOKUP
);
2856 /* We should not get here if the global_namespace is not yet constructed
2857 nor if NAME designates the global namespace: The global scope is
2858 constructed elsewhere. */
2859 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
2863 /* The name of anonymous namespace is unique for the translation
2865 if (!anonymous_namespace_name
)
2866 anonymous_namespace_name
= get_file_function_name ('N');
2867 name
= anonymous_namespace_name
;
2868 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2870 /* Reopening anonymous namespace. */
2876 /* Check whether this is an extended namespace definition. */
2877 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2878 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2881 if (DECL_NAMESPACE_ALIAS (d
))
2883 error ("namespace alias %qD not allowed here, assuming %qD",
2884 d
, DECL_NAMESPACE_ALIAS (d
));
2885 d
= DECL_NAMESPACE_ALIAS (d
);
2892 /* Make a new namespace, binding the name to it. */
2893 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2894 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
2898 /* Clear DECL_NAME for the benefit of debugging back ends. */
2899 SET_DECL_ASSEMBLER_NAME (d
, name
);
2900 DECL_NAME (d
) = NULL_TREE
;
2902 begin_scope (sk_namespace
, d
);
2905 resume_scope (NAMESPACE_LEVEL (d
));
2908 do_using_directive (d
);
2909 /* Enter the name space. */
2910 current_namespace
= d
;
2912 timevar_pop (TV_NAME_LOOKUP
);
2915 /* Pop from the scope of the current namespace. */
2918 pop_namespace (void)
2920 gcc_assert (current_namespace
!= global_namespace
);
2921 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2922 /* The binding level is not popped, as it might be re-opened later. */
2926 /* Push into the scope of the namespace NS, even if it is deeply
2927 nested within another namespace. */
2930 push_nested_namespace (tree ns
)
2932 if (ns
== global_namespace
)
2933 push_to_top_level ();
2936 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2937 push_namespace (DECL_NAME (ns
));
2941 /* Pop back from the scope of the namespace NS, which was previously
2942 entered with push_nested_namespace. */
2945 pop_nested_namespace (tree ns
)
2947 timevar_push (TV_NAME_LOOKUP
);
2948 while (ns
!= global_namespace
)
2951 ns
= CP_DECL_CONTEXT (ns
);
2954 pop_from_top_level ();
2955 timevar_pop (TV_NAME_LOOKUP
);
2958 /* Temporarily set the namespace for the current declaration. */
2961 push_decl_namespace (tree decl
)
2963 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
2964 decl
= decl_namespace_context (decl
);
2965 decl_namespace_list
= tree_cons (ORIGINAL_NAMESPACE (decl
),
2966 NULL_TREE
, decl_namespace_list
);
2969 /* [namespace.memdef]/2 */
2972 pop_decl_namespace (void)
2974 decl_namespace_list
= TREE_CHAIN (decl_namespace_list
);
2977 /* Return the namespace that is the common ancestor
2978 of two given namespaces. */
2981 namespace_ancestor (tree ns1
, tree ns2
)
2983 timevar_push (TV_NAME_LOOKUP
);
2984 if (is_ancestor (ns1
, ns2
))
2985 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ns1
);
2986 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
2987 namespace_ancestor (CP_DECL_CONTEXT (ns1
), ns2
));
2990 /* Process a namespace-alias declaration. */
2993 do_namespace_alias (tree alias
, tree
namespace)
2995 if (TREE_CODE (namespace) != NAMESPACE_DECL
)
2997 /* The parser did not find it, so it's not there. */
2998 error ("unknown namespace %qD", namespace);
3002 namespace = ORIGINAL_NAMESPACE (namespace);
3004 /* Build the alias. */
3005 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3006 DECL_NAMESPACE_ALIAS (alias
) = namespace;
3007 DECL_EXTERNAL (alias
) = 1;
3008 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3011 /* Emit debug info for namespace alias. */
3012 (*debug_hooks
->global_decl
) (alias
);
3015 /* Like pushdecl, only it places X in the current namespace,
3019 pushdecl_namespace_level (tree x
)
3021 struct cp_binding_level
*b
= current_binding_level
;
3024 timevar_push (TV_NAME_LOOKUP
);
3025 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
3027 /* Now, the type_shadowed stack may screw us. Munge it so it does
3029 if (TREE_CODE (t
) == TYPE_DECL
)
3031 tree name
= DECL_NAME (t
);
3033 tree
*ptr
= (tree
*)0;
3034 for (; !global_scope_p (b
); b
= b
->level_chain
)
3036 tree shadowed
= b
->type_shadowed
;
3037 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3038 if (TREE_PURPOSE (shadowed
) == name
)
3040 ptr
= &TREE_VALUE (shadowed
);
3041 /* Can't break out of the loop here because sometimes
3042 a binding level will have duplicate bindings for
3043 PT names. It's gross, but I haven't time to fix it. */
3046 newval
= TREE_TYPE (t
);
3047 if (ptr
== (tree
*)0)
3049 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3050 up here if this is changed to an assertion. --KR */
3051 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3058 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3061 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3062 directive is not directly from the source. Also find the common
3063 ancestor and let our users know about the new namespace */
3065 add_using_namespace (tree user
, tree used
, bool indirect
)
3068 timevar_push (TV_NAME_LOOKUP
);
3069 /* Using oneself is a no-op. */
3072 timevar_pop (TV_NAME_LOOKUP
);
3075 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3076 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3077 /* Check if we already have this. */
3078 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3082 /* Promote to direct usage. */
3083 TREE_INDIRECT_USING (t
) = 0;
3084 timevar_pop (TV_NAME_LOOKUP
);
3088 /* Add used to the user's using list. */
3089 DECL_NAMESPACE_USING (user
)
3090 = tree_cons (used
, namespace_ancestor (user
, used
),
3091 DECL_NAMESPACE_USING (user
));
3093 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3095 /* Add user to the used's users list. */
3096 DECL_NAMESPACE_USERS (used
)
3097 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3099 /* Recursively add all namespaces used. */
3100 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3101 /* indirect usage */
3102 add_using_namespace (user
, TREE_PURPOSE (t
), 1);
3104 /* Tell everyone using us about the new used namespaces. */
3105 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3106 add_using_namespace (TREE_PURPOSE (t
), used
, 1);
3107 timevar_pop (TV_NAME_LOOKUP
);
3110 /* Process a using-declaration not appearing in class or local scope. */
3113 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3115 tree oldval
, oldtype
, newval
, newtype
;
3116 tree orig_decl
= decl
;
3117 cxx_binding
*binding
;
3119 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3120 if (decl
== NULL_TREE
)
3123 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3125 oldval
= binding
->value
;
3126 oldtype
= binding
->type
;
3128 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3130 /* Emit debug info. */
3131 if (!processing_template_decl
)
3132 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3134 /* Copy declarations found. */
3136 binding
->value
= newval
;
3138 binding
->type
= newtype
;
3142 /* Process a using-directive. */
3145 do_using_directive (tree
namespace)
3147 tree context
= NULL_TREE
;
3149 if (building_stmt_tree ())
3150 add_stmt (build_stmt (USING_STMT
, namespace));
3152 /* using namespace A::B::C; */
3153 if (TREE_CODE (namespace) == SCOPE_REF
)
3154 namespace = TREE_OPERAND (namespace, 1);
3155 if (TREE_CODE (namespace) == IDENTIFIER_NODE
)
3157 /* Lookup in lexer did not find a namespace. */
3158 if (!processing_template_decl
)
3159 error ("namespace %qT undeclared", namespace);
3162 if (TREE_CODE (namespace) != NAMESPACE_DECL
)
3164 if (!processing_template_decl
)
3165 error ("%qT is not a namespace", namespace);
3168 namespace = ORIGINAL_NAMESPACE (namespace);
3169 if (!toplevel_bindings_p ())
3171 push_using_directive (namespace);
3172 context
= current_scope ();
3177 add_using_namespace (current_namespace
, namespace, 0);
3178 if (current_namespace
!= global_namespace
)
3179 context
= current_namespace
;
3182 /* Emit debugging info. */
3183 if (!processing_template_decl
)
3184 (*debug_hooks
->imported_module_or_decl
) (namespace, context
);
3187 /* Deal with a using-directive seen by the parser. Currently we only
3188 handle attributes here, since they cannot appear inside a template. */
3191 parse_using_directive (tree
namespace, tree attribs
)
3195 do_using_directive (namespace);
3197 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3199 tree name
= TREE_PURPOSE (a
);
3200 if (is_attribute_p ("strong", name
))
3202 if (!toplevel_bindings_p ())
3203 error ("strong using only meaningful at namespace scope");
3204 else if (namespace != error_mark_node
)
3205 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3206 = tree_cons (current_namespace
, 0,
3207 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3210 warning ("%qD attribute directive ignored", name
);
3214 /* Like pushdecl, only it places X in the global scope if appropriate.
3215 Calls cp_finish_decl to register the variable, initializing it with
3216 *INIT, if INIT is non-NULL. */
3219 pushdecl_top_level_1 (tree x
, tree
*init
)
3221 timevar_push (TV_NAME_LOOKUP
);
3222 push_to_top_level ();
3223 x
= pushdecl_namespace_level (x
);
3225 cp_finish_decl (x
, *init
, NULL_TREE
, 0);
3226 pop_from_top_level ();
3227 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
3230 /* Like pushdecl, only it places X in the global scope if appropriate. */
3233 pushdecl_top_level (tree x
)
3235 return pushdecl_top_level_1 (x
, NULL
);
3238 /* Like pushdecl, only it places X in the global scope if
3239 appropriate. Calls cp_finish_decl to register the variable,
3240 initializing it with INIT. */
3243 pushdecl_top_level_and_finish (tree x
, tree init
)
3245 return pushdecl_top_level_1 (x
, &init
);
3248 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3249 duplicates. The first list becomes the tail of the result.
3251 The algorithm is O(n^2). We could get this down to O(n log n) by
3252 doing a sort on the addresses of the functions, if that becomes
3256 merge_functions (tree s1
, tree s2
)
3258 for (; s2
; s2
= OVL_NEXT (s2
))
3260 tree fn2
= OVL_CURRENT (s2
);
3263 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3265 tree fn1
= OVL_CURRENT (fns1
);
3267 /* If the function from S2 is already in S1, there is no
3268 need to add it again. For `extern "C"' functions, we
3269 might have two FUNCTION_DECLs for the same function, in
3270 different namespaces; again, we only need one of them. */
3272 || (DECL_EXTERN_C_P (fn1
) && DECL_EXTERN_C_P (fn2
)
3273 && DECL_NAME (fn1
) == DECL_NAME (fn2
)))
3277 /* If we exhausted all of the functions in S1, FN2 is new. */
3279 s1
= build_overload (fn2
, s1
);
3284 /* This should return an error not all definitions define functions.
3285 It is not an error if we find two functions with exactly the
3286 same signature, only if these are selected in overload resolution.
3287 old is the current set of bindings, new the freshly-found binding.
3288 XXX Do we want to give *all* candidates in case of ambiguity?
3289 XXX In what way should I treat extern declarations?
3290 XXX I don't want to repeat the entire duplicate_decls here */
3293 ambiguous_decl (tree name
, struct scope_binding
*old
, cxx_binding
*new,
3297 gcc_assert (old
!= NULL
);
3298 /* Copy the value. */
3301 switch (TREE_CODE (val
))
3304 /* If we expect types or namespaces, and not templates,
3305 or this is not a template class. */
3306 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
3307 && !DECL_CLASS_TEMPLATE_P (val
))
3308 || hidden_name_p (val
))
3312 if (LOOKUP_NAMESPACES_ONLY (flags
) || hidden_name_p (val
))
3315 case NAMESPACE_DECL
:
3316 if (LOOKUP_TYPES_ONLY (flags
))
3320 /* Ignore built-in functions that are still anticipated. */
3321 if (LOOKUP_QUALIFIERS_ONLY (flags
) || hidden_name_p (val
))
3325 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3331 else if (val
&& val
!= old
->value
)
3333 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3334 old
->value
= merge_functions (old
->value
, val
);
3337 /* Some declarations are functions, some are not. */
3338 if (flags
& LOOKUP_COMPLAIN
)
3340 /* If we've already given this error for this lookup,
3341 old->value is error_mark_node, so let's not
3342 repeat ourselves. */
3343 if (old
->value
!= error_mark_node
)
3345 error ("use of %qD is ambiguous", name
);
3346 cp_error_at (" first declared as %q#D here", old
->value
);
3348 cp_error_at (" also declared as %q#D here", val
);
3350 old
->value
= error_mark_node
;
3353 /* ... and copy the type. */
3355 if (LOOKUP_NAMESPACES_ONLY (flags
))
3359 else if (type
&& old
->type
!= type
)
3361 if (flags
& LOOKUP_COMPLAIN
)
3363 error ("%qD denotes an ambiguous type",name
);
3364 error ("%J first type here", TYPE_MAIN_DECL (old
->type
));
3365 error ("%J other type here", TYPE_MAIN_DECL (type
));
3370 /* Return the declarations that are members of the namespace NS. */
3373 cp_namespace_decls (tree ns
)
3375 return NAMESPACE_LEVEL (ns
)->names
;
3378 /* Combine prefer_type and namespaces_only into flags. */
3381 lookup_flags (int prefer_type
, int namespaces_only
)
3383 if (namespaces_only
)
3384 return LOOKUP_PREFER_NAMESPACES
;
3385 if (prefer_type
> 1)
3386 return LOOKUP_PREFER_TYPES
;
3387 if (prefer_type
> 0)
3388 return LOOKUP_PREFER_BOTH
;
3392 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3393 ignore it or not. Subroutine of lookup_name_real and
3394 lookup_type_scope. */
3397 qualify_lookup (tree val
, int flags
)
3399 if (val
== NULL_TREE
)
3401 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3403 if ((flags
& LOOKUP_PREFER_TYPES
)
3404 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3406 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
3411 /* Given a lookup that returned VAL, decide if we want to ignore it or
3412 not based on DECL_ANTICIPATED_P. */
3415 hidden_name_p (tree val
)
3418 && DECL_LANG_SPECIFIC (val
)
3419 && DECL_ANTICIPATED (val
))
3424 /* Look up NAME in the NAMESPACE. */
3427 lookup_namespace_name (tree
namespace, tree name
)
3430 tree template_id
= NULL_TREE
;
3431 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3433 timevar_push (TV_NAME_LOOKUP
);
3434 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL
);
3436 if (TREE_CODE (name
) == NAMESPACE_DECL
)
3437 /* This happens for A::B<int> when B is a namespace. */
3438 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, name
);
3439 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
3441 /* This happens for A::B where B is a template, and there are no
3442 template arguments. */
3443 error ("invalid use of %qD", name
);
3444 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3447 namespace = ORIGINAL_NAMESPACE (namespace);
3449 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3452 name
= TREE_OPERAND (name
, 0);
3453 if (TREE_CODE (name
) == OVERLOAD
)
3454 name
= DECL_NAME (OVL_CURRENT (name
));
3455 else if (DECL_P (name
))
3456 name
= DECL_NAME (name
);
3459 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
3461 if (!qualified_lookup_using_namespace (name
, namespace, &binding
, 0))
3462 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3466 val
= binding
.value
;
3470 if (DECL_CLASS_TEMPLATE_P (val
))
3471 val
= lookup_template_class (val
,
3472 TREE_OPERAND (template_id
, 1),
3473 /*in_decl=*/NULL_TREE
,
3474 /*context=*/NULL_TREE
,
3475 /*entering_scope=*/0,
3476 tf_error
| tf_warning
);
3477 else if (DECL_FUNCTION_TEMPLATE_P (val
)
3478 || TREE_CODE (val
) == OVERLOAD
)
3479 val
= lookup_template_function (val
,
3480 TREE_OPERAND (template_id
, 1));
3483 error ("%<%D::%D%> is not a template", namespace, name
);
3484 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3488 /* If we have a single function from a using decl, pull it out. */
3489 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
3490 val
= OVL_FUNCTION (val
);
3492 /* Ignore built-in functions and friends that haven't been declared
3494 if (!val
|| !hidden_name_p (val
))
3495 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3498 error ("%qD undeclared in namespace %qD", name
, namespace);
3499 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3502 /* Select the right _DECL from multiple choices. */
3505 select_decl (const struct scope_binding
*binding
, int flags
)
3508 val
= binding
->value
;
3510 timevar_push (TV_NAME_LOOKUP
);
3511 if (LOOKUP_NAMESPACES_ONLY (flags
))
3513 /* We are not interested in types. */
3514 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
3515 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3516 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3519 /* If looking for a type, or if there is no non-type binding, select
3520 the value binding. */
3521 if (binding
->type
&& (!val
|| (flags
& LOOKUP_PREFER_TYPES
)))
3522 val
= binding
->type
;
3523 /* Don't return non-types if we really prefer types. */
3524 else if (val
&& LOOKUP_TYPES_ONLY (flags
)
3525 && ! DECL_DECLARES_TYPE_P (val
))
3528 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3531 /* Unscoped lookup of a global: iterate over current namespaces,
3532 considering using-directives. */
3535 unqualified_namespace_lookup (tree name
, int flags
)
3537 tree initial
= current_decl_namespace ();
3538 tree scope
= initial
;
3540 struct cp_binding_level
*level
;
3541 tree val
= NULL_TREE
;
3542 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3544 timevar_push (TV_NAME_LOOKUP
);
3546 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
3549 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3553 if (b
->value
&& hidden_name_p (b
->value
))
3554 /* Ignore anticipated built-in functions and friends. */
3557 binding
.value
= b
->value
;
3558 binding
.type
= b
->type
;
3561 /* Add all _DECLs seen through local using-directives. */
3562 for (level
= current_binding_level
;
3563 level
->kind
!= sk_namespace
;
3564 level
= level
->level_chain
)
3565 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
3567 /* Give up because of error. */
3568 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3570 /* Add all _DECLs seen through global using-directives. */
3571 /* XXX local and global using lists should work equally. */
3575 if (!lookup_using_namespace (name
, &binding
,
3576 DECL_NAMESPACE_USING (siter
),
3578 /* Give up because of error. */
3579 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3580 if (siter
== scope
) break;
3581 siter
= CP_DECL_CONTEXT (siter
);
3584 val
= select_decl (&binding
, flags
);
3585 if (scope
== global_namespace
)
3588 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3591 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3592 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3595 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3596 declaration found. If no suitable declaration can be found,
3597 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3598 neither a class-type nor a namespace a diagnostic is issued. */
3601 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
3605 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3607 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
3609 flags
|= LOOKUP_COMPLAIN
;
3611 flags
|= LOOKUP_PREFER_TYPES
;
3612 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
3613 return select_decl (&binding
, flags
);
3615 else if (is_aggr_type (scope
, complain
))
3618 t
= lookup_member (scope
, name
, 2, is_type_p
);
3623 return error_mark_node
;
3626 /* Subroutine of unqualified_namespace_lookup:
3627 Add the bindings of NAME in used namespaces to VAL.
3628 We are currently looking for names in namespace SCOPE, so we
3629 look through USINGS for using-directives of namespaces
3630 which have SCOPE as a common ancestor with the current scope.
3631 Returns false on errors. */
3634 lookup_using_namespace (tree name
, struct scope_binding
*val
,
3635 tree usings
, tree scope
, int flags
)
3638 timevar_push (TV_NAME_LOOKUP
);
3639 /* Iterate over all used namespaces in current, searching for using
3640 directives of scope. */
3641 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
3642 if (TREE_VALUE (iter
) == scope
)
3644 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
3646 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
3647 /* Resolve ambiguities. */
3649 ambiguous_decl (name
, val
, val1
, flags
);
3651 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
->value
!= error_mark_node
);
3655 Accepts the NAME to lookup and its qualifying SCOPE.
3656 Returns the name/type pair found into the cxx_binding *RESULT,
3657 or false on error. */
3660 qualified_lookup_using_namespace (tree name
, tree scope
,
3661 struct scope_binding
*result
, int flags
)
3663 /* Maintain a list of namespaces visited... */
3664 tree seen
= NULL_TREE
;
3665 /* ... and a list of namespace yet to see. */
3666 tree todo
= NULL_TREE
;
3667 tree todo_maybe
= NULL_TREE
;
3669 timevar_push (TV_NAME_LOOKUP
);
3670 /* Look through namespace aliases. */
3671 scope
= ORIGINAL_NAMESPACE (scope
);
3672 while (scope
&& result
->value
!= error_mark_node
)
3674 cxx_binding
*binding
=
3675 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3676 seen
= tree_cons (scope
, NULL_TREE
, seen
);
3678 ambiguous_decl (name
, result
, binding
, flags
);
3680 /* Consider strong using directives always, and non-strong ones
3681 if we haven't found a binding yet. ??? Shouldn't we consider
3682 non-strong ones if the initial RESULT is non-NULL, but the
3683 binding in the given namespace is? */
3684 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
3685 usings
= TREE_CHAIN (usings
))
3686 /* If this was a real directive, and we have not seen it. */
3687 if (!TREE_INDIRECT_USING (usings
))
3689 /* Try to avoid queuing the same namespace more than once,
3690 the exception being when a namespace was already
3691 enqueued for todo_maybe and then a strong using is
3692 found for it. We could try to remove it from
3693 todo_maybe, but it's probably not worth the effort. */
3694 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
))
3695 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3696 && !purpose_member (TREE_PURPOSE (usings
), todo
))
3697 todo
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
, todo
);
3698 else if ((!result
->value
&& !result
->type
)
3699 && !purpose_member (TREE_PURPOSE (usings
), seen
)
3700 && !purpose_member (TREE_PURPOSE (usings
), todo
)
3701 && !purpose_member (TREE_PURPOSE (usings
), todo_maybe
))
3702 todo_maybe
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
,
3707 scope
= TREE_PURPOSE (todo
);
3708 todo
= TREE_CHAIN (todo
);
3711 && (!result
->value
&& !result
->type
))
3713 scope
= TREE_PURPOSE (todo_maybe
);
3714 todo
= TREE_CHAIN (todo_maybe
);
3715 todo_maybe
= NULL_TREE
;
3718 scope
= NULL_TREE
; /* If there never was a todo list. */
3720 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
->value
!= error_mark_node
);
3723 /* Return the innermost non-namespace binding for NAME from a scope
3724 containing BINDING, or, if BINDING is NULL, the current scope. If
3725 CLASS_P is false, then class bindings are ignored. */
3728 outer_binding (tree name
,
3729 cxx_binding
*binding
,
3734 cxx_scope
*outer_scope
;
3738 scope
= binding
->scope
->level_chain
;
3739 outer
= binding
->previous
;
3743 scope
= current_binding_level
;
3744 outer
= IDENTIFIER_BINDING (name
);
3746 outer_scope
= outer
? outer
->scope
: NULL
;
3748 /* Because we create class bindings lazily, we might be missing a
3749 class binding for NAME. If there are any class binding levels
3750 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3751 declared, we must lookup NAME in those class scopes. */
3753 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
3755 if (scope
->kind
== sk_class
)
3757 cxx_binding
*class_binding
;
3759 class_binding
= get_class_binding (name
, scope
);
3762 /* Thread this new class-scope binding onto the
3763 IDENTIFIER_BINDING list so that future lookups
3765 class_binding
->previous
= outer
;
3767 binding
->previous
= class_binding
;
3769 IDENTIFIER_BINDING (name
) = class_binding
;
3770 return class_binding
;
3773 scope
= scope
->level_chain
;
3779 /* Return the innermost block-scope or class-scope value binding for
3780 NAME, or NULL_TREE if there is no such binding. */
3783 innermost_non_namespace_value (tree name
)
3785 cxx_binding
*binding
;
3786 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
3787 return binding
? binding
->value
: NULL_TREE
;
3790 /* Look up NAME in the current binding level and its superiors in the
3791 namespace of variables, functions and typedefs. Return a ..._DECL
3792 node of some kind representing its definition if there is only one
3793 such declaration, or return a TREE_LIST with all the overloaded
3794 definitions if there are many, or return 0 if it is undefined.
3795 Hidden name, either friend declaration or built-in function, are
3798 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3799 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3800 Otherwise we prefer non-TYPE_DECLs.
3802 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3803 BLOCK_P is false, bindings in block scopes are ignored. */
3806 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
3807 int namespaces_only
, int flags
)
3810 tree val
= NULL_TREE
;
3812 timevar_push (TV_NAME_LOOKUP
);
3813 /* Conversion operators are handled specially because ordinary
3814 unqualified name lookup will not find template conversion
3816 if (IDENTIFIER_TYPENAME_P (name
))
3818 struct cp_binding_level
*level
;
3820 for (level
= current_binding_level
;
3821 level
&& level
->kind
!= sk_namespace
;
3822 level
= level
->level_chain
)
3827 /* A conversion operator can only be declared in a class
3829 if (level
->kind
!= sk_class
)
3832 /* Lookup the conversion operator in the class. */
3833 class_type
= level
->this_entity
;
3834 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
3836 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, operators
);
3839 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3842 flags
|= lookup_flags (prefer_type
, namespaces_only
);
3844 /* First, look in non-namespace scopes. */
3846 if (current_class_type
== NULL_TREE
)
3849 if (block_p
|| !nonclass
)
3850 for (iter
= outer_binding (name
, NULL
, !nonclass
);
3852 iter
= outer_binding (name
, iter
, !nonclass
))
3856 /* Skip entities we don't want. */
3857 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
3860 /* If this is the kind of thing we're looking for, we're done. */
3861 if (qualify_lookup (iter
->value
, flags
)
3862 && !hidden_name_p (iter
->value
))
3863 binding
= iter
->value
;
3864 else if ((flags
& LOOKUP_PREFER_TYPES
)
3865 && qualify_lookup (iter
->type
, flags
)
3866 && !hidden_name_p (iter
->type
))
3867 binding
= iter
->type
;
3869 binding
= NULL_TREE
;
3878 /* Now lookup in namespace scopes. */
3880 val
= unqualified_namespace_lookup (name
, flags
);
3884 /* If we have a single function from a using decl, pull it out. */
3885 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
3886 val
= OVL_FUNCTION (val
);
3889 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3893 lookup_name_nonclass (tree name
)
3895 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN
);
3899 lookup_function_nonclass (tree name
, tree args
, bool block_p
)
3902 lookup_arg_dependent (name
,
3903 lookup_name_real (name
, 0, 1, block_p
, 0,
3909 lookup_name (tree name
, int prefer_type
)
3911 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true,
3912 0, LOOKUP_COMPLAIN
);
3915 /* Look up NAME for type used in elaborated name specifier in
3916 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
3917 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
3918 name, more scopes are checked if cleanup or template parameter
3919 scope is encountered.
3921 Unlike lookup_name_real, we make sure that NAME is actually
3922 declared in the desired scope, not from inheritance, nor using
3923 directive. For using declaration, there is DR138 still waiting
3924 to be resolved. Hidden name coming from earlier an friend
3925 declaration is also returned.
3927 A TYPE_DECL best matching the NAME is returned. Catching error
3928 and issuing diagnostics are caller's responsibility. */
3931 lookup_type_scope (tree name
, tag_scope scope
)
3933 cxx_binding
*iter
= NULL
;
3934 tree val
= NULL_TREE
;
3936 timevar_push (TV_NAME_LOOKUP
);
3938 /* Look in non-namespace scope first. */
3939 if (current_binding_level
->kind
!= sk_namespace
)
3940 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
3941 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
3943 /* Check if this is the kind of thing we're looking for.
3944 If SCOPE is TS_CURRENT, also make sure it doesn't come from
3945 base class. For ITER->VALUE, we can simply use
3946 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
3949 We check ITER->TYPE before ITER->VALUE in order to handle
3950 typedef struct C {} C;
3953 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
3954 && (scope
!= ts_current
3955 || LOCAL_BINDING_P (iter
)
3956 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
3958 else if ((scope
!= ts_current
3959 || !INHERITED_VALUE_BINDING_P (iter
))
3960 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
3967 /* Look in namespace scope. */
3970 iter
= cxx_scope_find_binding_for_name
3971 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
3975 /* If this is the kind of thing we're looking for, we're done. */
3976 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
3978 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
3984 /* Type found, check if it is in the allowed scopes, ignoring cleanup
3985 and template parameter scopes. */
3988 struct cp_binding_level
*b
= current_binding_level
;
3991 if (iter
->scope
== b
)
3992 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3994 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
)
3996 else if (b
->kind
== sk_class
3997 && scope
== ts_within_enclosing_non_class
)
4004 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4007 /* Similar to `lookup_name' but look only in the innermost non-class
4011 lookup_name_innermost_nonclass_level (tree name
)
4013 struct cp_binding_level
*b
;
4016 timevar_push (TV_NAME_LOOKUP
);
4017 b
= innermost_nonclass_level ();
4019 if (b
->kind
== sk_namespace
)
4021 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4023 /* extern "C" function() */
4024 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4027 else if (IDENTIFIER_BINDING (name
)
4028 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4030 cxx_binding
*binding
;
4031 binding
= IDENTIFIER_BINDING (name
);
4034 if (binding
->scope
== b
4035 && !(TREE_CODE (binding
->value
) == VAR_DECL
4036 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4037 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
->value
);
4039 if (b
->kind
== sk_cleanup
)
4046 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4049 /* Like lookup_name_innermost_nonclass_level, but for types. */
4052 lookup_type_current_level (tree name
)
4056 timevar_push (TV_NAME_LOOKUP
);
4057 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
4059 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
4060 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
4062 struct cp_binding_level
*b
= current_binding_level
;
4065 if (purpose_member (name
, b
->type_shadowed
))
4066 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
4067 REAL_IDENTIFIER_TYPE_VALUE (name
));
4068 if (b
->kind
== sk_cleanup
)
4075 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4078 /* [basic.lookup.koenig] */
4079 /* A nonzero return value in the functions below indicates an error. */
4089 static bool arg_assoc (struct arg_lookup
*, tree
);
4090 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4091 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4092 static bool add_function (struct arg_lookup
*, tree
);
4093 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4094 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4095 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4097 /* Add a function to the lookup structure.
4098 Returns true on error. */
4101 add_function (struct arg_lookup
*k
, tree fn
)
4103 /* We used to check here to see if the function was already in the list,
4104 but that's O(n^2), which is just too expensive for function lookup.
4105 Now we deal with the occasional duplicate in joust. In doing this, we
4106 assume that the number of duplicates will be small compared to the
4107 total number of functions being compared, which should usually be the
4110 /* We must find only functions, or exactly one non-function. */
4113 else if (fn
== k
->functions
)
4115 else if (is_overloaded_fn (k
->functions
) && is_overloaded_fn (fn
))
4116 k
->functions
= build_overload (fn
, k
->functions
);
4119 tree f1
= OVL_CURRENT (k
->functions
);
4121 if (is_overloaded_fn (f1
))
4123 fn
= f1
; f1
= f2
; f2
= fn
;
4125 cp_error_at ("%qD is not a function,", f1
);
4126 cp_error_at (" conflict with %qD", f2
);
4127 error (" in call to %qD", k
->name
);
4134 /* Returns true iff CURRENT has declared itself to be an associated
4135 namespace of SCOPE via a strong using-directive (or transitive chain
4136 thereof). Both are namespaces. */
4139 is_associated_namespace (tree current
, tree scope
)
4141 tree seen
= NULL_TREE
;
4142 tree todo
= NULL_TREE
;
4146 if (scope
== current
)
4148 seen
= tree_cons (scope
, NULL_TREE
, seen
);
4149 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4150 if (!purpose_member (TREE_PURPOSE (t
), seen
))
4151 todo
= tree_cons (TREE_PURPOSE (t
), NULL_TREE
, todo
);
4154 scope
= TREE_PURPOSE (todo
);
4155 todo
= TREE_CHAIN (todo
);
4162 /* Add functions of a namespace to the lookup structure.
4163 Returns true on error. */
4166 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4170 if (purpose_member (scope
, k
->namespaces
))
4172 k
->namespaces
= tree_cons (scope
, NULL_TREE
, k
->namespaces
);
4174 /* Check out our super-users. */
4175 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4176 value
= TREE_CHAIN (value
))
4177 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4180 value
= namespace_binding (k
->name
, scope
);
4184 for (; value
; value
= OVL_NEXT (value
))
4185 if (add_function (k
, OVL_CURRENT (value
)))
4191 /* Adds everything associated with a template argument to the lookup
4192 structure. Returns true on error. */
4195 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4197 /* [basic.lookup.koenig]
4199 If T is a template-id, its associated namespaces and classes are
4200 ... the namespaces and classes associated with the types of the
4201 template arguments provided for template type parameters
4202 (excluding template template parameters); the namespaces in which
4203 any template template arguments are defined; and the classes in
4204 which any member templates used as template template arguments
4205 are defined. [Note: non-type template arguments do not
4206 contribute to the set of associated namespaces. ] */
4208 /* Consider first template template arguments. */
4209 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4210 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
4212 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
4214 tree ctx
= CP_DECL_CONTEXT (arg
);
4216 /* It's not a member template. */
4217 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4218 return arg_assoc_namespace (k
, ctx
);
4219 /* Otherwise, it must be member template. */
4221 return arg_assoc_class (k
, ctx
);
4223 /* It's not a template template argument, but it is a type template
4225 else if (TYPE_P (arg
))
4226 return arg_assoc_type (k
, arg
);
4227 /* It's a non-type template argument. */
4232 /* Adds everything associated with class to the lookup structure.
4233 Returns true on error. */
4236 arg_assoc_class (struct arg_lookup
*k
, tree type
)
4238 tree list
, friends
, context
;
4241 /* Backend build structures, such as __builtin_va_list, aren't
4242 affected by all this. */
4243 if (!CLASS_TYPE_P (type
))
4246 if (purpose_member (type
, k
->classes
))
4248 k
->classes
= tree_cons (type
, NULL_TREE
, k
->classes
);
4250 context
= decl_namespace_context (type
);
4251 if (arg_assoc_namespace (k
, context
))
4254 if (TYPE_BINFO (type
))
4256 /* Process baseclasses. */
4257 tree binfo
, base_binfo
;
4259 for (binfo
= TYPE_BINFO (type
), i
= 0;
4260 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
4261 if (arg_assoc_class (k
, BINFO_TYPE (base_binfo
)))
4265 /* Process friends. */
4266 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
4267 list
= TREE_CHAIN (list
))
4268 if (k
->name
== FRIEND_NAME (list
))
4269 for (friends
= FRIEND_DECLS (list
); friends
;
4270 friends
= TREE_CHAIN (friends
))
4272 tree fn
= TREE_VALUE (friends
);
4274 /* Only interested in global functions with potentially hidden
4275 (i.e. unqualified) declarations. */
4276 if (CP_DECL_CONTEXT (fn
) != context
)
4278 /* Template specializations are never found by name lookup.
4279 (Templates themselves can be found, but not template
4280 specializations.) */
4281 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
4283 if (add_function (k
, fn
))
4287 /* Process template arguments. */
4288 if (CLASSTYPE_TEMPLATE_INFO (type
)
4289 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
4291 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
4292 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
4293 arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
));
4299 /* Adds everything associated with a given type.
4300 Returns 1 on error. */
4303 arg_assoc_type (struct arg_lookup
*k
, tree type
)
4305 /* As we do not get the type of non-type dependent expressions
4306 right, we can end up with such things without a type. */
4310 if (TYPE_PTRMEM_P (type
))
4312 /* Pointer to member: associate class type and value type. */
4313 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
4315 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
4317 else switch (TREE_CODE (type
))
4330 if (TYPE_PTRMEMFUNC_P (type
))
4331 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
4332 return arg_assoc_class (k
, type
);
4334 case REFERENCE_TYPE
:
4336 return arg_assoc_type (k
, TREE_TYPE (type
));
4339 return arg_assoc_namespace (k
, decl_namespace_context (type
));
4341 /* The basetype is referenced in the first arg type, so just
4344 /* Associate the parameter types. */
4345 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
4347 /* Associate the return type. */
4348 return arg_assoc_type (k
, TREE_TYPE (type
));
4349 case TEMPLATE_TYPE_PARM
:
4350 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4355 gcc_assert (type
== unknown_type_node
);
4363 /* Adds everything associated with arguments. Returns true on error. */
4366 arg_assoc_args (struct arg_lookup
*k
, tree args
)
4368 for (; args
; args
= TREE_CHAIN (args
))
4369 if (arg_assoc (k
, TREE_VALUE (args
)))
4374 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4377 arg_assoc (struct arg_lookup
*k
, tree n
)
4379 if (n
== error_mark_node
)
4383 return arg_assoc_type (k
, n
);
4385 if (! type_unknown_p (n
))
4386 return arg_assoc_type (k
, TREE_TYPE (n
));
4388 if (TREE_CODE (n
) == ADDR_EXPR
)
4389 n
= TREE_OPERAND (n
, 0);
4390 if (TREE_CODE (n
) == COMPONENT_REF
)
4391 n
= TREE_OPERAND (n
, 1);
4392 if (TREE_CODE (n
) == OFFSET_REF
)
4393 n
= TREE_OPERAND (n
, 1);
4394 while (TREE_CODE (n
) == TREE_LIST
)
4396 if (TREE_CODE (n
) == BASELINK
)
4397 n
= BASELINK_FUNCTIONS (n
);
4399 if (TREE_CODE (n
) == FUNCTION_DECL
)
4400 return arg_assoc_type (k
, TREE_TYPE (n
));
4401 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
4403 /* [basic.lookup.koenig]
4405 If T is a template-id, its associated namespaces and classes
4406 are the namespace in which the template is defined; for
4407 member templates, the member template's class... */
4408 tree
template = TREE_OPERAND (n
, 0);
4409 tree args
= TREE_OPERAND (n
, 1);
4413 if (TREE_CODE (template) == COMPONENT_REF
)
4414 template = TREE_OPERAND (template, 1);
4416 /* First, the template. There may actually be more than one if
4417 this is an overloaded function template. But, in that case,
4418 we only need the first; all the functions will be in the same
4420 template = OVL_CURRENT (template);
4422 ctx
= CP_DECL_CONTEXT (template);
4424 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4426 if (arg_assoc_namespace (k
, ctx
) == 1)
4429 /* It must be a member template. */
4430 else if (arg_assoc_class (k
, ctx
) == 1)
4433 /* Now the arguments. */
4434 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
4435 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
4438 else if (TREE_CODE (n
) == OVERLOAD
)
4440 for (; n
; n
= OVL_CHAIN (n
))
4441 if (arg_assoc_type (k
, TREE_TYPE (OVL_FUNCTION (n
))))
4448 /* Performs Koenig lookup depending on arguments, where fns
4449 are the functions found in normal lookup. */
4452 lookup_arg_dependent (tree name
, tree fns
, tree args
)
4454 struct arg_lookup k
;
4455 tree fn
= NULL_TREE
;
4457 timevar_push (TV_NAME_LOOKUP
);
4460 k
.classes
= NULL_TREE
;
4462 /* We've already looked at some namespaces during normal unqualified
4463 lookup -- but we don't know exactly which ones. If the functions
4464 we found were brought into the current namespace via a using
4465 declaration, we have not really checked the namespace from which
4466 they came. Therefore, we check all namespaces here -- unless the
4467 function we have is from the current namespace. Even then, we
4468 must check all namespaces if the function is a local
4469 declaration; any other declarations present at namespace scope
4470 should be visible during argument-dependent lookup. */
4472 fn
= OVL_CURRENT (fns
);
4473 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
4474 && (CP_DECL_CONTEXT (fn
) != current_decl_namespace ()
4475 || DECL_LOCAL_FUNCTION_P (fn
)))
4476 k
.namespaces
= NULL_TREE
;
4478 /* Setting NAMESPACES is purely an optimization; it prevents
4479 adding functions which are already in FNS. Adding them would
4480 be safe -- "joust" will eliminate the duplicates -- but
4482 k
.namespaces
= build_tree_list (current_decl_namespace (), NULL_TREE
);
4484 arg_assoc_args (&k
, args
);
4485 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, k
.functions
);
4488 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4489 changed (i.e. there was already a directive), or the fresh
4490 TREE_LIST otherwise. */
4493 push_using_directive (tree used
)
4495 tree ud
= current_binding_level
->using_directives
;
4496 tree iter
, ancestor
;
4498 timevar_push (TV_NAME_LOOKUP
);
4499 /* Check if we already have this. */
4500 if (purpose_member (used
, ud
) != NULL_TREE
)
4501 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4503 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4504 ud
= current_binding_level
->using_directives
;
4505 ud
= tree_cons (used
, ancestor
, ud
);
4506 current_binding_level
->using_directives
= ud
;
4508 /* Recursively add all namespaces used. */
4509 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4510 push_using_directive (TREE_PURPOSE (iter
));
4512 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ud
);
4515 /* The type TYPE is being declared. If it is a class template, or a
4516 specialization of a class template, do any processing required and
4517 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4518 being declared a friend. B is the binding level at which this TYPE
4521 Returns the TYPE_DECL for TYPE, which may have been altered by this
4525 maybe_process_template_type_declaration (tree type
, int is_friend
,
4528 tree decl
= TYPE_NAME (type
);
4530 if (processing_template_parmlist
)
4531 /* You can't declare a new template type in a template parameter
4532 list. But, you can declare a non-template type:
4534 template <class A*> struct S;
4536 is a forward-declaration of `A'. */
4540 gcc_assert (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ENUMERAL_TYPE
);
4542 if (processing_template_decl
)
4544 /* This may change after the call to
4545 push_template_decl_real, but we want the original value. */
4546 tree name
= DECL_NAME (decl
);
4548 decl
= push_template_decl_real (decl
, is_friend
);
4549 /* If the current binding level is the binding level for the
4550 template parameters (see the comment in
4551 begin_template_parm_list) and the enclosing level is a class
4552 scope, and we're not looking at a friend, push the
4553 declaration of the member class into the class scope. In the
4554 friend case, push_template_decl will already have put the
4555 friend into global scope, if appropriate. */
4556 if (TREE_CODE (type
) != ENUMERAL_TYPE
4557 && !is_friend
&& b
->kind
== sk_template_parms
4558 && b
->level_chain
->kind
== sk_class
)
4560 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
4562 if (!COMPLETE_TYPE_P (current_class_type
))
4564 maybe_add_class_template_decl_list (current_class_type
,
4565 type
, /*friend_p=*/0);
4566 /* Put this UDT in the table of UDTs for the class. */
4567 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
4568 CLASSTYPE_NESTED_UTDS (current_class_type
) =
4569 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4571 binding_table_insert
4572 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
4581 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4582 that the NAME is a class template, the tag is processed but not pushed.
4584 The pushed scope depend on the SCOPE parameter:
4585 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4587 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4588 non-template-parameter scope. This case is needed for forward
4590 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4591 TS_GLOBAL case except that names within template-parameter scopes
4592 are not pushed at all.
4594 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4597 pushtag (tree name
, tree type
, tag_scope scope
)
4599 struct cp_binding_level
*b
;
4601 timevar_push (TV_NAME_LOOKUP
);
4602 b
= current_binding_level
;
4603 while (/* Cleanup scopes are not scopes from the point of view of
4605 b
->kind
== sk_cleanup
4606 /* Neither are the scopes used to hold template parameters
4607 for an explicit specialization. For an ordinary template
4608 declaration, these scopes are not scopes from the point of
4609 view of the language. */
4610 || (b
->kind
== sk_template_parms
4611 && (b
->explicit_spec_p
|| scope
== ts_global
))
4612 || (b
->kind
== sk_class
4613 && (scope
!= ts_current
4614 /* We may be defining a new type in the initializer
4615 of a static member variable. We allow this when
4616 not pedantic, and it is particularly useful for
4617 type punning via an anonymous union. */
4618 || COMPLETE_TYPE_P (b
->this_entity
))))
4623 /* Do C++ gratuitous typedefing. */
4624 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
4628 tree context
= TYPE_CONTEXT (type
);
4632 tree cs
= current_scope ();
4634 if (scope
== ts_current
)
4636 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
4637 /* When declaring a friend class of a local class, we want
4638 to inject the newly named class into the scope
4639 containing the local class, not the namespace scope. */
4640 context
= decl_function_context (get_type_decl (cs
));
4643 context
= current_namespace
;
4645 if (b
->kind
== sk_class
4646 || (b
->kind
== sk_template_parms
4647 && b
->level_chain
->kind
== sk_class
))
4650 if (current_lang_name
== lang_name_java
)
4651 TYPE_FOR_JAVA (type
) = 1;
4653 d
= create_implicit_typedef (name
, type
);
4654 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
4655 if (scope
== ts_within_enclosing_non_class
)
4657 /* This is a friend. Make this TYPE_DECL node hidden from
4658 ordinary name lookup. Its corresponding TEMPLATE_DECL
4659 will be marked in push_template_decl_real. */
4660 retrofit_lang_decl (d
);
4661 DECL_ANTICIPATED (d
) = 1;
4662 DECL_FRIEND_P (d
) = 1;
4666 set_identifier_type_value_with_scope (name
, d
, b
);
4668 d
= maybe_process_template_type_declaration
4669 (type
, scope
== ts_within_enclosing_non_class
, b
);
4670 if (d
== error_mark_node
)
4671 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
4673 if (b
->kind
== sk_class
)
4675 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4676 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4677 class. But if it's a member template class, we
4678 want the TEMPLATE_DECL, not the TYPE_DECL, so this
4680 finish_member_declaration (d
);
4682 pushdecl_class_level (d
);
4684 else if (b
->kind
!= sk_template_parms
)
4685 d
= pushdecl_with_scope (d
, b
);
4687 if (d
== error_mark_node
)
4688 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
4690 /* FIXME what if it gets a name from typedef? */
4691 if (ANON_AGGRNAME_P (name
))
4692 DECL_IGNORED_P (d
) = 1;
4694 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
4696 /* If this is a local class, keep track of it. We need this
4697 information for name-mangling, and so that it is possible to find
4698 all function definitions in a translation unit in a convenient
4699 way. (It's otherwise tricky to find a member function definition
4700 it's only pointed to from within a local class.) */
4701 if (TYPE_CONTEXT (type
)
4702 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
4703 && !processing_template_decl
)
4704 VARRAY_PUSH_TREE (local_classes
, type
);
4706 if (b
->kind
== sk_class
4707 && !COMPLETE_TYPE_P (current_class_type
))
4709 maybe_add_class_template_decl_list (current_class_type
,
4710 type
, /*friend_p=*/0);
4712 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
4713 CLASSTYPE_NESTED_UTDS (current_class_type
)
4714 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4716 binding_table_insert
4717 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
4721 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
4722 /* Use the canonical TYPE_DECL for this node. */
4723 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
4726 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
4727 will be the tagged type we just added to the current
4728 binding level. This fake NULL-named TYPE_DECL node helps
4729 dwarfout.c to know when it needs to output a
4730 representation of a tagged type, and it also gives us a
4731 convenient place to record the "scope start" address for
4734 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
4735 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
4737 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, type
);
4740 /* Subroutines for reverting temporarily to top-level for instantiation
4741 of templates and such. We actually need to clear out the class- and
4742 local-value slots of all identifiers, so that only the global values
4743 are at all visible. Simply setting current_binding_level to the global
4744 scope isn't enough, because more binding levels may be pushed. */
4745 struct saved_scope
*scope_chain
;
4747 /* If ID has not already been marked, add an appropriate binding to
4751 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
4753 cxx_saved_binding
*saved
;
4755 if (!id
|| !IDENTIFIER_BINDING (id
))
4758 if (IDENTIFIER_MARKED (id
))
4761 IDENTIFIER_MARKED (id
) = 1;
4763 saved
= VEC_safe_push (cxx_saved_binding
, gc
, *old_bindings
, NULL
);
4764 saved
->identifier
= id
;
4765 saved
->binding
= IDENTIFIER_BINDING (id
);
4766 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
4767 IDENTIFIER_BINDING (id
) = NULL
;
4771 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
4775 timevar_push (TV_NAME_LOOKUP
);
4776 for (t
= names
; t
; t
= TREE_CHAIN (t
))
4780 if (TREE_CODE (t
) == TREE_LIST
)
4781 id
= TREE_PURPOSE (t
);
4785 store_binding (id
, old_bindings
);
4787 timevar_pop (TV_NAME_LOOKUP
);
4790 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4791 objects, rather than a TREE_LIST. */
4794 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
4795 VEC(cxx_saved_binding
,gc
) **old_bindings
)
4798 cp_class_binding
*cb
;
4800 timevar_push (TV_NAME_LOOKUP
);
4801 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
4802 store_binding (cb
->identifier
, old_bindings
);
4803 timevar_pop (TV_NAME_LOOKUP
);
4807 push_to_top_level (void)
4809 struct saved_scope
*s
;
4810 struct cp_binding_level
*b
;
4811 cxx_saved_binding
*sb
;
4815 timevar_push (TV_NAME_LOOKUP
);
4816 s
= GGC_CNEW (struct saved_scope
);
4818 b
= scope_chain
? current_binding_level
: 0;
4820 /* If we're in the middle of some function, save our state. */
4824 push_function_context_to (NULL_TREE
);
4829 if (scope_chain
&& previous_class_level
)
4830 store_class_bindings (previous_class_level
->class_shadowed
,
4833 /* Have to include the global scope, because class-scope decls
4834 aren't listed anywhere useful. */
4835 for (; b
; b
= b
->level_chain
)
4839 /* Template IDs are inserted into the global level. If they were
4840 inserted into namespace level, finish_file wouldn't find them
4841 when doing pending instantiations. Therefore, don't stop at
4842 namespace level, but continue until :: . */
4843 if (global_scope_p (b
))
4846 store_bindings (b
->names
, &s
->old_bindings
);
4847 /* We also need to check class_shadowed to save class-level type
4848 bindings, since pushclass doesn't fill in b->names. */
4849 if (b
->kind
== sk_class
)
4850 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
4852 /* Unwind type-value slots back to top level. */
4853 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
4854 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
4857 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, sb
); ++i
)
4858 IDENTIFIER_MARKED (sb
->identifier
) = 0;
4860 s
->prev
= scope_chain
;
4862 s
->need_pop_function_context
= need_pop
;
4863 s
->function_decl
= current_function_decl
;
4866 current_function_decl
= NULL_TREE
;
4867 VARRAY_TREE_INIT (current_lang_base
, 10, "current_lang_base");
4868 current_lang_name
= lang_name_cplusplus
;
4869 current_namespace
= global_namespace
;
4870 timevar_pop (TV_NAME_LOOKUP
);
4874 pop_from_top_level (void)
4876 struct saved_scope
*s
= scope_chain
;
4877 cxx_saved_binding
*saved
;
4880 timevar_push (TV_NAME_LOOKUP
);
4881 /* Clear out class-level bindings cache. */
4882 if (previous_class_level
)
4883 invalidate_class_lookup_cache ();
4885 current_lang_base
= 0;
4887 scope_chain
= s
->prev
;
4888 for (i
= 0; VEC_iterate (cxx_saved_binding
, s
->old_bindings
, i
, saved
); ++i
)
4890 tree id
= saved
->identifier
;
4892 IDENTIFIER_BINDING (id
) = saved
->binding
;
4893 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
4896 /* If we were in the middle of compiling a function, restore our
4898 if (s
->need_pop_function_context
)
4899 pop_function_context_from (NULL_TREE
);
4900 current_function_decl
= s
->function_decl
;
4901 timevar_pop (TV_NAME_LOOKUP
);
4904 /* Pop off extraneous binding levels left over due to syntax errors.
4906 We don't pop past namespaces, as they might be valid. */
4909 pop_everything (void)
4911 if (ENABLE_SCOPE_CHECKING
)
4912 verbatim ("XXX entering pop_everything ()\n");
4913 while (!toplevel_bindings_p ())
4915 if (current_binding_level
->kind
== sk_class
)
4916 pop_nested_class ();
4920 if (ENABLE_SCOPE_CHECKING
)
4921 verbatim ("XXX leaving pop_everything ()\n");
4924 /* Emit debugging information for using declarations and directives.
4925 If input tree is overloaded fn then emit debug info for all
4929 cp_emit_debug_info_for_using (tree t
, tree context
)
4931 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
4932 of a builtin function. */
4933 if (TREE_CODE (t
) == FUNCTION_DECL
4934 && DECL_EXTERNAL (t
)
4935 && DECL_BUILT_IN (t
))
4938 /* Do not supply context to imported_module_or_decl, if
4939 it is a global namespace. */
4940 if (context
== global_namespace
)
4941 context
= NULL_TREE
;
4944 t
= BASELINK_FUNCTIONS (t
);
4946 /* FIXME: Handle TEMPLATE_DECLs. */
4947 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
4948 if (TREE_CODE (t
) != TEMPLATE_DECL
)
4949 (*debug_hooks
->imported_module_or_decl
) (t
, context
);
4952 #include "gt-cp-name-lookup.h"