Merge branch 'vendor/GCC47'
[dragonfly.git] / contrib / gcc-4.7 / gcc / cp / name-lookup.c
CommitLineData
e4b17023
JM
1/* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 3, or (at your option)
11any later version.
12
13GCC is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
26#include "flags.h"
27#include "tree.h"
28#include "cp-tree.h"
29#include "name-lookup.h"
30#include "timevar.h"
31#include "diagnostic-core.h"
32#include "intl.h"
33#include "debug.h"
34#include "c-family/c-pragma.h"
35#include "params.h"
36#include "pointer-set.h"
37
38/* The bindings for a particular name in a particular scope. */
39
40struct scope_binding {
41 tree value;
42 tree type;
43};
44#define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
45
46static cp_binding_level *innermost_nonclass_level (void);
47static cxx_binding *binding_for_name (cp_binding_level *, tree);
48static tree push_overloaded_decl (tree, int, bool);
49static bool lookup_using_namespace (tree, struct scope_binding *, tree,
50 tree, int);
51static bool qualified_lookup_using_namespace (tree, tree,
52 struct scope_binding *, int);
53static tree lookup_type_current_level (tree);
54static tree push_using_directive (tree);
55static tree lookup_extern_c_fun_in_all_ns (tree);
56static void diagnose_name_conflict (tree, tree);
57
58/* The :: namespace. */
59
60tree global_namespace;
61
62/* The name of the anonymous namespace, throughout this translation
63 unit. */
64static GTY(()) tree anonymous_namespace_name;
65
66/* Initialize anonymous_namespace_name if necessary, and return it. */
67
68static tree
69get_anonymous_namespace_name (void)
70{
71 if (!anonymous_namespace_name)
72 {
73 /* The anonymous namespace has to have a unique name
74 if typeinfo objects are being compared by name. */
75 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
76 anonymous_namespace_name = get_file_function_name ("N");
77 else
78 /* The demangler expects anonymous namespaces to be called
79 something starting with '_GLOBAL__N_'. */
80 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
81 }
82 return anonymous_namespace_name;
83}
84
85/* Compute the chain index of a binding_entry given the HASH value of its
86 name and the total COUNT of chains. COUNT is assumed to be a power
87 of 2. */
88
89#define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
90
91/* A free list of "binding_entry"s awaiting for re-use. */
92
93static GTY((deletable)) binding_entry free_binding_entry = NULL;
94
95/* Create a binding_entry object for (NAME, TYPE). */
96
97static inline binding_entry
98binding_entry_make (tree name, tree type)
99{
100 binding_entry entry;
101
102 if (free_binding_entry)
103 {
104 entry = free_binding_entry;
105 free_binding_entry = entry->chain;
106 }
107 else
108 entry = ggc_alloc_binding_entry_s ();
109
110 entry->name = name;
111 entry->type = type;
112 entry->chain = NULL;
113
114 return entry;
115}
116
117/* Put ENTRY back on the free list. */
118#if 0
119static inline void
120binding_entry_free (binding_entry entry)
121{
122 entry->name = NULL;
123 entry->type = NULL;
124 entry->chain = free_binding_entry;
125 free_binding_entry = entry;
126}
127#endif
128
129/* The datatype used to implement the mapping from names to types at
130 a given scope. */
131struct GTY(()) binding_table_s {
132 /* Array of chains of "binding_entry"s */
133 binding_entry * GTY((length ("%h.chain_count"))) chain;
134
135 /* The number of chains in this table. This is the length of the
136 member "chain" considered as an array. */
137 size_t chain_count;
138
139 /* Number of "binding_entry"s in this table. */
140 size_t entry_count;
141};
142
143/* Construct TABLE with an initial CHAIN_COUNT. */
144
145static inline void
146binding_table_construct (binding_table table, size_t chain_count)
147{
148 table->chain_count = chain_count;
149 table->entry_count = 0;
150 table->chain = ggc_alloc_cleared_vec_binding_entry (table->chain_count);
151}
152
153/* Make TABLE's entries ready for reuse. */
154#if 0
155static void
156binding_table_free (binding_table table)
157{
158 size_t i;
159 size_t count;
160
161 if (table == NULL)
162 return;
163
164 for (i = 0, count = table->chain_count; i < count; ++i)
165 {
166 binding_entry temp = table->chain[i];
167 while (temp != NULL)
168 {
169 binding_entry entry = temp;
170 temp = entry->chain;
171 binding_entry_free (entry);
172 }
173 table->chain[i] = NULL;
174 }
175 table->entry_count = 0;
176}
177#endif
178
179/* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
180
181static inline binding_table
182binding_table_new (size_t chain_count)
183{
184 binding_table table = ggc_alloc_binding_table_s ();
185 table->chain = NULL;
186 binding_table_construct (table, chain_count);
187 return table;
188}
189
190/* Expand TABLE to twice its current chain_count. */
191
192static void
193binding_table_expand (binding_table table)
194{
195 const size_t old_chain_count = table->chain_count;
196 const size_t old_entry_count = table->entry_count;
197 const size_t new_chain_count = 2 * old_chain_count;
198 binding_entry *old_chains = table->chain;
199 size_t i;
200
201 binding_table_construct (table, new_chain_count);
202 for (i = 0; i < old_chain_count; ++i)
203 {
204 binding_entry entry = old_chains[i];
205 for (; entry != NULL; entry = old_chains[i])
206 {
207 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
208 const size_t j = ENTRY_INDEX (hash, new_chain_count);
209
210 old_chains[i] = entry->chain;
211 entry->chain = table->chain[j];
212 table->chain[j] = entry;
213 }
214 }
215 table->entry_count = old_entry_count;
216}
217
218/* Insert a binding for NAME to TYPE into TABLE. */
219
220static void
221binding_table_insert (binding_table table, tree name, tree type)
222{
223 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
224 const size_t i = ENTRY_INDEX (hash, table->chain_count);
225 binding_entry entry = binding_entry_make (name, type);
226
227 entry->chain = table->chain[i];
228 table->chain[i] = entry;
229 ++table->entry_count;
230
231 if (3 * table->chain_count < 5 * table->entry_count)
232 binding_table_expand (table);
233}
234
235/* Return the binding_entry, if any, that maps NAME. */
236
237binding_entry
238binding_table_find (binding_table table, tree name)
239{
240 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
241 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
242
243 while (entry != NULL && entry->name != name)
244 entry = entry->chain;
245
246 return entry;
247}
248
249/* Apply PROC -- with DATA -- to all entries in TABLE. */
250
251void
252binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
253{
5ce9237c 254 size_t chain_count;
e4b17023
JM
255 size_t i;
256
5ce9237c
JM
257 if (!table)
258 return;
259
260 chain_count = table->chain_count;
e4b17023
JM
261 for (i = 0; i < chain_count; ++i)
262 {
263 binding_entry entry = table->chain[i];
264 for (; entry != NULL; entry = entry->chain)
265 proc (entry, data);
266 }
267}
268\f
269#ifndef ENABLE_SCOPE_CHECKING
270# define ENABLE_SCOPE_CHECKING 0
271#else
272# define ENABLE_SCOPE_CHECKING 1
273#endif
274
275/* A free list of "cxx_binding"s, connected by their PREVIOUS. */
276
277static GTY((deletable)) cxx_binding *free_bindings;
278
279/* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
280 field to NULL. */
281
282static inline void
283cxx_binding_init (cxx_binding *binding, tree value, tree type)
284{
285 binding->value = value;
286 binding->type = type;
287 binding->previous = NULL;
288}
289
290/* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
291
292static cxx_binding *
293cxx_binding_make (tree value, tree type)
294{
295 cxx_binding *binding;
296 if (free_bindings)
297 {
298 binding = free_bindings;
299 free_bindings = binding->previous;
300 }
301 else
302 binding = ggc_alloc_cxx_binding ();
303
304 cxx_binding_init (binding, value, type);
305
306 return binding;
307}
308
309/* Put BINDING back on the free list. */
310
311static inline void
312cxx_binding_free (cxx_binding *binding)
313{
314 binding->scope = NULL;
315 binding->previous = free_bindings;
316 free_bindings = binding;
317}
318
319/* Create a new binding for NAME (with the indicated VALUE and TYPE
320 bindings) in the class scope indicated by SCOPE. */
321
322static cxx_binding *
323new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
324{
325 cp_class_binding *cb;
326 cxx_binding *binding;
327
328 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
329
330 cb->identifier = name;
331 cb->base = binding = cxx_binding_make (value, type);
332 binding->scope = scope;
333 return binding;
334}
335
336/* Make DECL the innermost binding for ID. The LEVEL is the binding
337 level at which this declaration is being bound. */
338
339static void
340push_binding (tree id, tree decl, cp_binding_level* level)
341{
342 cxx_binding *binding;
343
344 if (level != class_binding_level)
345 {
346 binding = cxx_binding_make (decl, NULL_TREE);
347 binding->scope = level;
348 }
349 else
350 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
351
352 /* Now, fill in the binding information. */
353 binding->previous = IDENTIFIER_BINDING (id);
354 INHERITED_VALUE_BINDING_P (binding) = 0;
355 LOCAL_BINDING_P (binding) = (level != class_binding_level);
356
357 /* And put it on the front of the list of bindings for ID. */
358 IDENTIFIER_BINDING (id) = binding;
359}
360
361/* Remove the binding for DECL which should be the innermost binding
362 for ID. */
363
364void
365pop_binding (tree id, tree decl)
366{
367 cxx_binding *binding;
368
369 if (id == NULL_TREE)
370 /* It's easiest to write the loops that call this function without
371 checking whether or not the entities involved have names. We
372 get here for such an entity. */
373 return;
374
375 /* Get the innermost binding for ID. */
376 binding = IDENTIFIER_BINDING (id);
377
378 /* The name should be bound. */
379 gcc_assert (binding != NULL);
380
381 /* The DECL will be either the ordinary binding or the type
382 binding for this identifier. Remove that binding. */
383 if (binding->value == decl)
384 binding->value = NULL_TREE;
385 else
386 {
387 gcc_assert (binding->type == decl);
388 binding->type = NULL_TREE;
389 }
390
391 if (!binding->value && !binding->type)
392 {
393 /* We're completely done with the innermost binding for this
394 identifier. Unhook it from the list of bindings. */
395 IDENTIFIER_BINDING (id) = binding->previous;
396
397 /* Add it to the free list. */
398 cxx_binding_free (binding);
399 }
400}
401
95d28233
JM
402/* Strip non dependent using declarations. If DECL is dependent,
403 surreptitiously create a typename_type and return it. */
e4b17023
JM
404
405tree
406strip_using_decl (tree decl)
407{
408 if (decl == NULL_TREE)
409 return NULL_TREE;
410
411 while (TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
412 decl = USING_DECL_DECLS (decl);
95d28233
JM
413
414 if (TREE_CODE (decl) == USING_DECL && DECL_DEPENDENT_P (decl)
415 && USING_DECL_TYPENAME_P (decl))
416 {
417 /* We have found a type introduced by a using
418 declaration at class scope that refers to a dependent
419 type.
420
421 using typename :: [opt] nested-name-specifier unqualified-id ;
422 */
423 decl = make_typename_type (TREE_TYPE (decl),
424 DECL_NAME (decl),
425 typename_type, tf_error);
426 if (decl != error_mark_node)
427 decl = TYPE_NAME (decl);
428 }
429
e4b17023
JM
430 return decl;
431}
432
433/* BINDING records an existing declaration for a name in the current scope.
434 But, DECL is another declaration for that same identifier in the
435 same scope. This is the `struct stat' hack whereby a non-typedef
436 class name or enum-name can be bound at the same level as some other
437 kind of entity.
438 3.3.7/1
439
440 A class name (9.1) or enumeration name (7.2) can be hidden by the
441 name of an object, function, or enumerator declared in the same scope.
442 If a class or enumeration name and an object, function, or enumerator
443 are declared in the same scope (in any order) with the same name, the
444 class or enumeration name is hidden wherever the object, function, or
445 enumerator name is visible.
446
447 It's the responsibility of the caller to check that
448 inserting this name is valid here. Returns nonzero if the new binding
449 was successful. */
450
451static bool
452supplement_binding_1 (cxx_binding *binding, tree decl)
453{
454 tree bval = binding->value;
455 bool ok = true;
456 tree target_bval = strip_using_decl (bval);
457 tree target_decl = strip_using_decl (decl);
458
459 if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
460 && target_decl != target_bval
461 && (TREE_CODE (target_bval) != TYPE_DECL
462 /* We allow pushing an enum multiple times in a class
463 template in order to handle late matching of underlying
464 type on an opaque-enum-declaration followed by an
465 enum-specifier. */
466 || (TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
467 && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
468 && (dependent_type_p (ENUM_UNDERLYING_TYPE
469 (TREE_TYPE (target_decl)))
470 || dependent_type_p (ENUM_UNDERLYING_TYPE
471 (TREE_TYPE (target_bval)))))))
472 /* The new name is the type name. */
473 binding->type = decl;
474 else if (/* TARGET_BVAL is null when push_class_level_binding moves
475 an inherited type-binding out of the way to make room
476 for a new value binding. */
477 !target_bval
478 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
479 has been used in a non-class scope prior declaration.
480 In that case, we should have already issued a
481 diagnostic; for graceful error recovery purpose, pretend
482 this was the intended declaration for that name. */
483 || target_bval == error_mark_node
484 /* If TARGET_BVAL is anticipated but has not yet been
485 declared, pretend it is not there at all. */
486 || (TREE_CODE (target_bval) == FUNCTION_DECL
487 && DECL_ANTICIPATED (target_bval)
488 && !DECL_HIDDEN_FRIEND_P (target_bval)))
489 binding->value = decl;
490 else if (TREE_CODE (target_bval) == TYPE_DECL
491 && DECL_ARTIFICIAL (target_bval)
492 && target_decl != target_bval
493 && (TREE_CODE (target_decl) != TYPE_DECL
494 || same_type_p (TREE_TYPE (target_decl),
495 TREE_TYPE (target_bval))))
496 {
497 /* The old binding was a type name. It was placed in
498 VALUE field because it was thought, at the point it was
499 declared, to be the only entity with such a name. Move the
500 type name into the type slot; it is now hidden by the new
501 binding. */
502 binding->type = bval;
503 binding->value = decl;
504 binding->value_is_inherited = false;
505 }
506 else if (TREE_CODE (target_bval) == TYPE_DECL
507 && TREE_CODE (target_decl) == TYPE_DECL
508 && DECL_NAME (target_decl) == DECL_NAME (target_bval)
509 && binding->scope->kind != sk_class
510 && (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval))
511 /* If either type involves template parameters, we must
512 wait until instantiation. */
513 || uses_template_parms (TREE_TYPE (target_decl))
514 || uses_template_parms (TREE_TYPE (target_bval))))
515 /* We have two typedef-names, both naming the same type to have
516 the same name. In general, this is OK because of:
517
518 [dcl.typedef]
519
520 In a given scope, a typedef specifier can be used to redefine
521 the name of any type declared in that scope to refer to the
522 type to which it already refers.
523
524 However, in class scopes, this rule does not apply due to the
525 stricter language in [class.mem] prohibiting redeclarations of
526 members. */
527 ok = false;
528 /* There can be two block-scope declarations of the same variable,
529 so long as they are `extern' declarations. However, there cannot
530 be two declarations of the same static data member:
531
532 [class.mem]
533
534 A member shall not be declared twice in the
535 member-specification. */
536 else if (TREE_CODE (target_decl) == VAR_DECL
537 && TREE_CODE (target_bval) == VAR_DECL
538 && DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval)
539 && !DECL_CLASS_SCOPE_P (target_decl))
540 {
541 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
542 ok = false;
543 }
544 else if (TREE_CODE (decl) == NAMESPACE_DECL
545 && TREE_CODE (bval) == NAMESPACE_DECL
546 && DECL_NAMESPACE_ALIAS (decl)
547 && DECL_NAMESPACE_ALIAS (bval)
548 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
549 /* [namespace.alias]
550
551 In a declarative region, a namespace-alias-definition can be
552 used to redefine a namespace-alias declared in that declarative
553 region to refer only to the namespace to which it already
554 refers. */
555 ok = false;
556 else
557 {
558 diagnose_name_conflict (decl, bval);
559 ok = false;
560 }
561
562 return ok;
563}
564
565/* Diagnose a name conflict between DECL and BVAL. */
566
567static void
568diagnose_name_conflict (tree decl, tree bval)
569{
570 if (TREE_CODE (decl) == TREE_CODE (bval)
571 && (TREE_CODE (decl) != TYPE_DECL
572 || (DECL_ARTIFICIAL (decl) && DECL_ARTIFICIAL (bval))
573 || (!DECL_ARTIFICIAL (decl) && !DECL_ARTIFICIAL (bval)))
574 && !is_overloaded_fn (decl))
575 error ("redeclaration of %q#D", decl);
576 else
577 error ("%q#D conflicts with a previous declaration", decl);
578
579 inform (input_location, "previous declaration %q+#D", bval);
580}
581
582/* Wrapper for supplement_binding_1. */
583
584static bool
585supplement_binding (cxx_binding *binding, tree decl)
586{
587 bool ret;
588 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
589 ret = supplement_binding_1 (binding, decl);
590 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
591 return ret;
592}
593
594/* Add DECL to the list of things declared in B. */
595
596static void
597add_decl_to_level (tree decl, cp_binding_level *b)
598{
599 /* We used to record virtual tables as if they were ordinary
600 variables, but no longer do so. */
601 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
602
603 if (TREE_CODE (decl) == NAMESPACE_DECL
604 && !DECL_NAMESPACE_ALIAS (decl))
605 {
606 DECL_CHAIN (decl) = b->namespaces;
607 b->namespaces = decl;
608 }
609 else
610 {
611 /* We build up the list in reverse order, and reverse it later if
612 necessary. */
613 TREE_CHAIN (decl) = b->names;
614 b->names = decl;
615
616 /* If appropriate, add decl to separate list of statics. We
617 include extern variables because they might turn out to be
618 static later. It's OK for this list to contain a few false
619 positives. */
620 if (b->kind == sk_namespace)
621 if ((TREE_CODE (decl) == VAR_DECL
622 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
623 || (TREE_CODE (decl) == FUNCTION_DECL
624 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
625 VEC_safe_push (tree, gc, b->static_decls, decl);
626 }
627}
628
629/* Record a decl-node X as belonging to the current lexical scope.
630 Check for errors (such as an incompatible declaration for the same
631 name already seen in the same scope). IS_FRIEND is true if X is
632 declared as a friend.
633
634 Returns either X or an old decl for the same name.
635 If an old decl is returned, it may have been smashed
636 to agree with what X says. */
637
638static tree
639pushdecl_maybe_friend_1 (tree x, bool is_friend)
640{
641 tree t;
642 tree name;
643 int need_new_binding;
644
645 if (x == error_mark_node)
646 return error_mark_node;
647
648 need_new_binding = 1;
649
650 if (DECL_TEMPLATE_PARM_P (x))
651 /* Template parameters have no context; they are not X::T even
652 when declared within a class or namespace. */
653 ;
654 else
655 {
656 if (current_function_decl && x != current_function_decl
657 /* A local declaration for a function doesn't constitute
658 nesting. */
659 && TREE_CODE (x) != FUNCTION_DECL
660 /* A local declaration for an `extern' variable is in the
661 scope of the current namespace, not the current
662 function. */
663 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
664 /* When parsing the parameter list of a function declarator,
665 don't set DECL_CONTEXT to an enclosing function. When we
666 push the PARM_DECLs in order to process the function body,
667 current_binding_level->this_entity will be set. */
668 && !(TREE_CODE (x) == PARM_DECL
669 && current_binding_level->kind == sk_function_parms
670 && current_binding_level->this_entity == NULL)
671 && !DECL_CONTEXT (x))
672 DECL_CONTEXT (x) = current_function_decl;
673
674 /* If this is the declaration for a namespace-scope function,
675 but the declaration itself is in a local scope, mark the
676 declaration. */
677 if (TREE_CODE (x) == FUNCTION_DECL
678 && DECL_NAMESPACE_SCOPE_P (x)
679 && current_function_decl
680 && x != current_function_decl)
681 DECL_LOCAL_FUNCTION_P (x) = 1;
682 }
683
684 name = DECL_NAME (x);
685 if (name)
686 {
687 int different_binding_level = 0;
688
689 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
690 name = TREE_OPERAND (name, 0);
691
692 /* In case this decl was explicitly namespace-qualified, look it
693 up in its namespace context. */
694 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
695 t = namespace_binding (name, DECL_CONTEXT (x));
696 else
697 t = lookup_name_innermost_nonclass_level (name);
698
699 /* [basic.link] If there is a visible declaration of an entity
700 with linkage having the same name and type, ignoring entities
701 declared outside the innermost enclosing namespace scope, the
702 block scope declaration declares that same entity and
703 receives the linkage of the previous declaration. */
704 if (! t && current_function_decl && x != current_function_decl
705 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
706 && DECL_EXTERNAL (x))
707 {
708 /* Look in block scope. */
709 t = innermost_non_namespace_value (name);
710 /* Or in the innermost namespace. */
711 if (! t)
712 t = namespace_binding (name, DECL_CONTEXT (x));
713 /* Does it have linkage? Note that if this isn't a DECL, it's an
714 OVERLOAD, which is OK. */
715 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
716 t = NULL_TREE;
717 if (t)
718 different_binding_level = 1;
719 }
720
721 /* If we are declaring a function, and the result of name-lookup
722 was an OVERLOAD, look for an overloaded instance that is
723 actually the same as the function we are declaring. (If
724 there is one, we have to merge our declaration with the
725 previous declaration.) */
726 if (t && TREE_CODE (t) == OVERLOAD)
727 {
728 tree match;
729
730 if (TREE_CODE (x) == FUNCTION_DECL)
731 for (match = t; match; match = OVL_NEXT (match))
732 {
733 if (decls_match (OVL_CURRENT (match), x))
734 break;
735 }
736 else
737 /* Just choose one. */
738 match = t;
739
740 if (match)
741 t = OVL_CURRENT (match);
742 else
743 t = NULL_TREE;
744 }
745
746 if (t && t != error_mark_node)
747 {
748 if (different_binding_level)
749 {
750 if (decls_match (x, t))
751 /* The standard only says that the local extern
752 inherits linkage from the previous decl; in
753 particular, default args are not shared. Add
754 the decl into a hash table to make sure only
755 the previous decl in this case is seen by the
756 middle end. */
757 {
758 struct cxx_int_tree_map *h;
759 void **loc;
760
761 TREE_PUBLIC (x) = TREE_PUBLIC (t);
762
763 if (cp_function_chain->extern_decl_map == NULL)
764 cp_function_chain->extern_decl_map
765 = htab_create_ggc (20, cxx_int_tree_map_hash,
766 cxx_int_tree_map_eq, NULL);
767
768 h = ggc_alloc_cxx_int_tree_map ();
769 h->uid = DECL_UID (x);
770 h->to = t;
771 loc = htab_find_slot_with_hash
772 (cp_function_chain->extern_decl_map, h,
773 h->uid, INSERT);
774 *(struct cxx_int_tree_map **) loc = h;
775 }
776 }
777 else if (TREE_CODE (t) == PARM_DECL)
778 {
779 /* Check for duplicate params. */
780 tree d = duplicate_decls (x, t, is_friend);
781 if (d)
782 return d;
783 }
784 else if ((DECL_EXTERN_C_FUNCTION_P (x)
785 || DECL_FUNCTION_TEMPLATE_P (x))
786 && is_overloaded_fn (t))
787 /* Don't do anything just yet. */;
788 else if (t == wchar_decl_node)
789 {
790 if (! DECL_IN_SYSTEM_HEADER (x))
791 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
792 TREE_TYPE (x));
793
794 /* Throw away the redeclaration. */
795 return t;
796 }
797 else
798 {
799 tree olddecl = duplicate_decls (x, t, is_friend);
800
801 /* If the redeclaration failed, we can stop at this
802 point. */
803 if (olddecl == error_mark_node)
804 return error_mark_node;
805
806 if (olddecl)
807 {
808 if (TREE_CODE (t) == TYPE_DECL)
809 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
810
811 return t;
812 }
813 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
814 {
815 /* A redeclaration of main, but not a duplicate of the
816 previous one.
817
818 [basic.start.main]
819
820 This function shall not be overloaded. */
821 error ("invalid redeclaration of %q+D", t);
822 error ("as %qD", x);
823 /* We don't try to push this declaration since that
824 causes a crash. */
825 return x;
826 }
827 }
828 }
829
830 /* If x has C linkage-specification, (extern "C"),
831 lookup its binding, in case it's already bound to an object.
832 The lookup is done in all namespaces.
833 If we find an existing binding, make sure it has the same
834 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
835 if ((TREE_CODE (x) == FUNCTION_DECL)
836 && DECL_EXTERN_C_P (x)
837 /* We should ignore declarations happening in system headers. */
838 && !DECL_ARTIFICIAL (x)
839 && !DECL_IN_SYSTEM_HEADER (x))
840 {
841 tree previous = lookup_extern_c_fun_in_all_ns (x);
842 if (previous
843 && !DECL_ARTIFICIAL (previous)
844 && !DECL_IN_SYSTEM_HEADER (previous)
845 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
846 {
847 /* In case either x or previous is declared to throw an exception,
848 make sure both exception specifications are equal. */
849 if (decls_match (x, previous))
850 {
851 tree x_exception_spec = NULL_TREE;
852 tree previous_exception_spec = NULL_TREE;
853
854 x_exception_spec =
855 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
856 previous_exception_spec =
857 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
858 if (!comp_except_specs (previous_exception_spec,
859 x_exception_spec,
860 ce_normal))
861 {
862 pedwarn (input_location, 0,
863 "declaration of %q#D with C language linkage",
864 x);
865 pedwarn (input_location, 0,
866 "conflicts with previous declaration %q+#D",
867 previous);
868 pedwarn (input_location, 0,
869 "due to different exception specifications");
870 return error_mark_node;
871 }
872 if (DECL_ASSEMBLER_NAME_SET_P (previous))
873 SET_DECL_ASSEMBLER_NAME (x,
874 DECL_ASSEMBLER_NAME (previous));
875 }
876 else
877 {
878 pedwarn (input_location, 0,
879 "declaration of %q#D with C language linkage", x);
880 pedwarn (input_location, 0,
881 "conflicts with previous declaration %q+#D",
882 previous);
883 }
884 }
885 }
886
887 check_template_shadow (x);
888
889 /* If this is a function conjured up by the back end, massage it
890 so it looks friendly. */
891 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
892 {
893 retrofit_lang_decl (x);
894 SET_DECL_LANGUAGE (x, lang_c);
895 }
896
897 t = x;
898 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
899 {
900 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
901 if (!namespace_bindings_p ())
902 /* We do not need to create a binding for this name;
903 push_overloaded_decl will have already done so if
904 necessary. */
905 need_new_binding = 0;
906 }
907 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
908 {
909 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
910 if (t == x)
911 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
912 }
913
914 if (TREE_CODE (t) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (t))
915 check_default_args (t);
916
917 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
918 return t;
919
920 /* If declaring a type as a typedef, copy the type (unless we're
921 at line 0), and install this TYPE_DECL as the new type's typedef
922 name. See the extensive comment of set_underlying_type (). */
923 if (TREE_CODE (x) == TYPE_DECL)
924 {
925 tree type = TREE_TYPE (x);
926
927 if (DECL_IS_BUILTIN (x)
928 || (TREE_TYPE (x) != error_mark_node
929 && TYPE_NAME (type) != x
930 /* We don't want to copy the type when all we're
931 doing is making a TYPE_DECL for the purposes of
932 inlining. */
933 && (!TYPE_NAME (type)
934 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
935 set_underlying_type (x);
936
937 if (type != error_mark_node
938 && TYPE_NAME (type)
939 && TYPE_IDENTIFIER (type))
940 set_identifier_type_value (DECL_NAME (x), x);
941
942 /* If this is a locally defined typedef in a function that
943 is not a template instantation, record it to implement
944 -Wunused-local-typedefs. */
945 if (current_instantiation () == NULL
946 || (current_instantiation ()->decl != current_function_decl))
947 record_locally_defined_typedef (x);
948 }
949
950 /* Multiple external decls of the same identifier ought to match.
951
952 We get warnings about inline functions where they are defined.
953 We get warnings about other functions from push_overloaded_decl.
954
955 Avoid duplicate warnings where they are used. */
956 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
957 {
958 tree decl;
959
960 decl = IDENTIFIER_NAMESPACE_VALUE (name);
961 if (decl && TREE_CODE (decl) == OVERLOAD)
962 decl = OVL_FUNCTION (decl);
963
964 if (decl && decl != error_mark_node
965 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
966 /* If different sort of thing, we already gave an error. */
967 && TREE_CODE (decl) == TREE_CODE (x)
968 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
969 {
970 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
971 permerror (input_location, "previous external decl of %q+#D", decl);
972 }
973 }
974
975 if (TREE_CODE (x) == FUNCTION_DECL
976 && is_friend
977 && !flag_friend_injection)
978 {
979 /* This is a new declaration of a friend function, so hide
980 it from ordinary function lookup. */
981 DECL_ANTICIPATED (x) = 1;
982 DECL_HIDDEN_FRIEND_P (x) = 1;
983 }
984
985 /* This name is new in its binding level.
986 Install the new declaration and return it. */
987 if (namespace_bindings_p ())
988 {
989 /* Install a global value. */
990
991 /* If the first global decl has external linkage,
992 warn if we later see static one. */
993 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
994 TREE_PUBLIC (name) = 1;
995
996 /* Bind the name for the entity. */
997 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
998 && t != NULL_TREE)
999 && (TREE_CODE (x) == TYPE_DECL
1000 || TREE_CODE (x) == VAR_DECL
1001 || TREE_CODE (x) == NAMESPACE_DECL
1002 || TREE_CODE (x) == CONST_DECL
1003 || TREE_CODE (x) == TEMPLATE_DECL))
1004 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
1005
1006 /* If new decl is `static' and an `extern' was seen previously,
1007 warn about it. */
1008 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
1009 warn_extern_redeclared_static (x, t);
1010 }
1011 else
1012 {
1013 /* Here to install a non-global value. */
1014 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
1015 tree oldlocal = NULL_TREE;
1016 cp_binding_level *oldscope = NULL;
1017 cxx_binding *oldbinding = outer_binding (name, NULL, true);
1018 if (oldbinding)
1019 {
1020 oldlocal = oldbinding->value;
1021 oldscope = oldbinding->scope;
1022 }
1023
1024 if (need_new_binding)
1025 {
1026 push_local_binding (name, x, 0);
1027 /* Because push_local_binding will hook X on to the
1028 current_binding_level's name list, we don't want to
1029 do that again below. */
1030 need_new_binding = 0;
1031 }
1032
1033 /* If this is a TYPE_DECL, push it into the type value slot. */
1034 if (TREE_CODE (x) == TYPE_DECL)
1035 set_identifier_type_value (name, x);
1036
1037 /* Clear out any TYPE_DECL shadowed by a namespace so that
1038 we won't think this is a type. The C struct hack doesn't
1039 go through namespaces. */
1040 if (TREE_CODE (x) == NAMESPACE_DECL)
1041 set_identifier_type_value (name, NULL_TREE);
1042
1043 if (oldlocal)
1044 {
1045 tree d = oldlocal;
1046
1047 while (oldlocal
1048 && TREE_CODE (oldlocal) == VAR_DECL
1049 && DECL_DEAD_FOR_LOCAL (oldlocal))
1050 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
1051
1052 if (oldlocal == NULL_TREE)
1053 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
1054 }
1055
1056 /* If this is an extern function declaration, see if we
1057 have a global definition or declaration for the function. */
1058 if (oldlocal == NULL_TREE
1059 && DECL_EXTERNAL (x)
1060 && oldglobal != NULL_TREE
1061 && TREE_CODE (x) == FUNCTION_DECL
1062 && TREE_CODE (oldglobal) == FUNCTION_DECL)
1063 {
1064 /* We have one. Their types must agree. */
1065 if (decls_match (x, oldglobal))
1066 /* OK */;
1067 else
1068 {
1069 warning (0, "extern declaration of %q#D doesn%'t match", x);
1070 warning (0, "global declaration %q+#D", oldglobal);
1071 }
1072 }
1073 /* If we have a local external declaration,
1074 and no file-scope declaration has yet been seen,
1075 then if we later have a file-scope decl it must not be static. */
1076 if (oldlocal == NULL_TREE
1077 && oldglobal == NULL_TREE
1078 && DECL_EXTERNAL (x)
1079 && TREE_PUBLIC (x))
1080 TREE_PUBLIC (name) = 1;
1081
1082 /* Don't complain about the parms we push and then pop
1083 while tentatively parsing a function declarator. */
1084 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1085 /* Ignore. */;
1086
1087 /* Warn if shadowing an argument at the top level of the body. */
1088 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1089 /* Inline decls shadow nothing. */
1090 && !DECL_FROM_INLINE (x)
1091 && (TREE_CODE (oldlocal) == PARM_DECL
1092 || TREE_CODE (oldlocal) == VAR_DECL
1093 /* If the old decl is a type decl, only warn if the
1094 old decl is an explicit typedef or if both the old
1095 and new decls are type decls. */
1096 || (TREE_CODE (oldlocal) == TYPE_DECL
1097 && (!DECL_ARTIFICIAL (oldlocal)
1098 || TREE_CODE (x) == TYPE_DECL)))
1099 /* Don't check for internally generated vars unless
1100 it's an implicit typedef (see create_implicit_typedef
1101 in decl.c). */
1102 && (!DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x)))
1103 {
1104 bool nowarn = false;
1105
1106 /* Don't complain if it's from an enclosing function. */
1107 if (DECL_CONTEXT (oldlocal) == current_function_decl
1108 && TREE_CODE (x) != PARM_DECL
1109 && TREE_CODE (oldlocal) == PARM_DECL)
1110 {
1111 /* Go to where the parms should be and see if we find
1112 them there. */
1113 cp_binding_level *b = current_binding_level->level_chain;
1114
1115 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1116 /* Skip the ctor/dtor cleanup level. */
1117 b = b->level_chain;
1118
1119 /* ARM $8.3 */
1120 if (b->kind == sk_function_parms)
1121 {
1122 error ("declaration of %q#D shadows a parameter", x);
1123 nowarn = true;
1124 }
1125 }
1126
1127 /* The local structure or class can't use parameters of
1128 the containing function anyway. */
1129 if (DECL_CONTEXT (oldlocal) != current_function_decl)
1130 {
1131 cp_binding_level *scope = current_binding_level;
1132 tree context = DECL_CONTEXT (oldlocal);
1133 for (; scope; scope = scope->level_chain)
1134 {
1135 if (scope->kind == sk_function_parms
1136 && scope->this_entity == context)
1137 break;
1138 if (scope->kind == sk_class
1139 && !LAMBDA_TYPE_P (scope->this_entity))
1140 {
1141 nowarn = true;
1142 break;
1143 }
1144 }
1145 }
1146 /* Error if redeclaring a local declared in a
1147 for-init-statement or in the condition of an if or
1148 switch statement when the new declaration is in the
1149 outermost block of the controlled statement.
1150 Redeclaring a variable from a for or while condition is
1151 detected elsewhere. */
1152 else if (TREE_CODE (oldlocal) == VAR_DECL
1153 && oldscope == current_binding_level->level_chain
1154 && (oldscope->kind == sk_cond
1155 || oldscope->kind == sk_for))
1156 {
1157 error ("redeclaration of %q#D", x);
1158 error ("%q+#D previously declared here", oldlocal);
1159 }
1160
1161 if (warn_shadow && !nowarn)
1162 {
1163 if (TREE_CODE (oldlocal) == PARM_DECL)
1164 warning_at (input_location, OPT_Wshadow,
1165 "declaration of %q#D shadows a parameter", x);
1166 else if (is_capture_proxy (oldlocal))
1167 warning_at (input_location, OPT_Wshadow,
1168 "declaration of %qD shadows a lambda capture",
1169 x);
1170 else
1171 warning_at (input_location, OPT_Wshadow,
1172 "declaration of %qD shadows a previous local",
1173 x);
1174 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1175 "shadowed declaration is here");
1176 }
1177 }
1178
1179 /* Maybe warn if shadowing something else. */
1180 else if (warn_shadow && !DECL_EXTERNAL (x)
1181 /* No shadow warnings for internally generated vars unless
1182 it's an implicit typedef (see create_implicit_typedef
1183 in decl.c). */
1184 && (! DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x))
1185 /* No shadow warnings for vars made for inlining. */
1186 && ! DECL_FROM_INLINE (x))
1187 {
1188 tree member;
1189
1190 if (current_class_ptr)
1191 member = lookup_member (current_class_type,
1192 name,
1193 /*protect=*/0,
1194 /*want_type=*/false,
1195 tf_warning_or_error);
1196 else
1197 member = NULL_TREE;
1198
1199 if (member && !TREE_STATIC (member))
1200 {
1201 /* Location of previous decl is not useful in this case. */
1202 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1203 x);
1204 }
1205 else if (oldglobal != NULL_TREE
1206 && (TREE_CODE (oldglobal) == VAR_DECL
1207 /* If the old decl is a type decl, only warn if the
1208 old decl is an explicit typedef or if both the
1209 old and new decls are type decls. */
1210 || (TREE_CODE (oldglobal) == TYPE_DECL
1211 && (!DECL_ARTIFICIAL (oldglobal)
1212 || TREE_CODE (x) == TYPE_DECL))))
1213 /* XXX shadow warnings in outer-more namespaces */
1214 {
1215 warning_at (input_location, OPT_Wshadow,
1216 "declaration of %qD shadows a global declaration", x);
1217 warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1218 "shadowed declaration is here");
1219 }
1220 }
1221 }
1222
1223 if (TREE_CODE (x) == VAR_DECL)
1224 maybe_register_incomplete_var (x);
1225 }
1226
1227 if (need_new_binding)
1228 add_decl_to_level (x,
1229 DECL_NAMESPACE_SCOPE_P (x)
1230 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1231 : current_binding_level);
1232
1233 return x;
1234}
1235
1236/* Wrapper for pushdecl_maybe_friend_1. */
1237
1238tree
1239pushdecl_maybe_friend (tree x, bool is_friend)
1240{
1241 tree ret;
1242 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1243 ret = pushdecl_maybe_friend_1 (x, is_friend);
1244 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1245 return ret;
1246}
1247
1248/* Record a decl-node X as belonging to the current lexical scope. */
1249
1250tree
1251pushdecl (tree x)
1252{
1253 return pushdecl_maybe_friend (x, false);
1254}
1255
1256/* Enter DECL into the symbol table, if that's appropriate. Returns
1257 DECL, or a modified version thereof. */
1258
1259tree
1260maybe_push_decl (tree decl)
1261{
1262 tree type = TREE_TYPE (decl);
1263
1264 /* Add this decl to the current binding level, but not if it comes
1265 from another scope, e.g. a static member variable. TEM may equal
1266 DECL or it may be a previous decl of the same name. */
1267 if (decl == error_mark_node
1268 || (TREE_CODE (decl) != PARM_DECL
1269 && DECL_CONTEXT (decl) != NULL_TREE
1270 /* Definitions of namespace members outside their namespace are
1271 possible. */
1272 && !DECL_NAMESPACE_SCOPE_P (decl))
1273 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1274 || type == unknown_type_node
1275 /* The declaration of a template specialization does not affect
1276 the functions available for overload resolution, so we do not
1277 call pushdecl. */
1278 || (TREE_CODE (decl) == FUNCTION_DECL
1279 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1280 return decl;
1281 else
1282 return pushdecl (decl);
1283}
1284
1285/* Bind DECL to ID in the current_binding_level, assumed to be a local
1286 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1287 doesn't really belong to this binding level, that it got here
1288 through a using-declaration. */
1289
1290void
1291push_local_binding (tree id, tree decl, int flags)
1292{
1293 cp_binding_level *b;
1294
1295 /* Skip over any local classes. This makes sense if we call
1296 push_local_binding with a friend decl of a local class. */
1297 b = innermost_nonclass_level ();
1298
1299 if (lookup_name_innermost_nonclass_level (id))
1300 {
1301 /* Supplement the existing binding. */
1302 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1303 /* It didn't work. Something else must be bound at this
1304 level. Do not add DECL to the list of things to pop
1305 later. */
1306 return;
1307 }
1308 else
1309 /* Create a new binding. */
1310 push_binding (id, decl, b);
1311
1312 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1313 /* We must put the OVERLOAD into a TREE_LIST since the
1314 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1315 decls that got here through a using-declaration. */
1316 decl = build_tree_list (NULL_TREE, decl);
1317
1318 /* And put DECL on the list of things declared by the current
1319 binding level. */
1320 add_decl_to_level (decl, b);
1321}
1322
1323/* Check to see whether or not DECL is a variable that would have been
1324 in scope under the ARM, but is not in scope under the ANSI/ISO
1325 standard. If so, issue an error message. If name lookup would
1326 work in both cases, but return a different result, this function
1327 returns the result of ANSI/ISO lookup. Otherwise, it returns
1328 DECL. */
1329
1330tree
1331check_for_out_of_scope_variable (tree decl)
1332{
1333 tree shadowed;
1334
1335 /* We only care about out of scope variables. */
1336 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1337 return decl;
1338
1339 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1340 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1341 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1342 && DECL_DEAD_FOR_LOCAL (shadowed))
1343 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1344 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1345 if (!shadowed)
1346 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1347 if (shadowed)
1348 {
1349 if (!DECL_ERROR_REPORTED (decl))
1350 {
1351 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1352 warning (0, " matches this %q+D under ISO standard rules",
1353 shadowed);
1354 warning (0, " matches this %q+D under old rules", decl);
1355 DECL_ERROR_REPORTED (decl) = 1;
1356 }
1357 return shadowed;
1358 }
1359
1360 /* If we have already complained about this declaration, there's no
1361 need to do it again. */
1362 if (DECL_ERROR_REPORTED (decl))
1363 return decl;
1364
1365 DECL_ERROR_REPORTED (decl) = 1;
1366
1367 if (TREE_TYPE (decl) == error_mark_node)
1368 return decl;
1369
1370 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1371 {
1372 error ("name lookup of %qD changed for ISO %<for%> scoping",
1373 DECL_NAME (decl));
1374 error (" cannot use obsolete binding at %q+D because "
1375 "it has a destructor", decl);
1376 return error_mark_node;
1377 }
1378 else
1379 {
1380 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1381 DECL_NAME (decl));
1382 if (flag_permissive)
1383 permerror (input_location, " using obsolete binding at %q+D", decl);
1384 else
1385 {
1386 static bool hint;
1387 if (!hint)
1388 {
1389 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1390 hint = true;
1391 }
1392 }
1393 }
1394
1395 return decl;
1396}
1397\f
1398/* true means unconditionally make a BLOCK for the next level pushed. */
1399
1400static bool keep_next_level_flag;
1401
1402static int binding_depth = 0;
1403
1404static void
1405indent (int depth)
1406{
1407 int i;
1408
1409 for (i = 0; i < depth * 2; i++)
1410 putc (' ', stderr);
1411}
1412
1413/* Return a string describing the kind of SCOPE we have. */
1414static const char *
1415cp_binding_level_descriptor (cp_binding_level *scope)
1416{
1417 /* The order of this table must match the "scope_kind"
1418 enumerators. */
1419 static const char* scope_kind_names[] = {
1420 "block-scope",
1421 "cleanup-scope",
1422 "try-scope",
1423 "catch-scope",
1424 "for-scope",
1425 "function-parameter-scope",
1426 "class-scope",
1427 "namespace-scope",
1428 "template-parameter-scope",
1429 "template-explicit-spec-scope"
1430 };
1431 const scope_kind kind = scope->explicit_spec_p
1432 ? sk_template_spec : scope->kind;
1433
1434 return scope_kind_names[kind];
1435}
1436
1437/* Output a debugging information about SCOPE when performing
1438 ACTION at LINE. */
1439static void
1440cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
1441{
1442 const char *desc = cp_binding_level_descriptor (scope);
1443 if (scope->this_entity)
1444 verbatim ("%s %s(%E) %p %d\n", action, desc,
1445 scope->this_entity, (void *) scope, line);
1446 else
1447 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1448}
1449
1450/* Return the estimated initial size of the hashtable of a NAMESPACE
1451 scope. */
1452
1453static inline size_t
1454namespace_scope_ht_size (tree ns)
1455{
1456 tree name = DECL_NAME (ns);
1457
1458 return name == std_identifier
1459 ? NAMESPACE_STD_HT_SIZE
1460 : (name == global_scope_name
1461 ? GLOBAL_SCOPE_HT_SIZE
1462 : NAMESPACE_ORDINARY_HT_SIZE);
1463}
1464
1465/* A chain of binding_level structures awaiting reuse. */
1466
1467static GTY((deletable)) cp_binding_level *free_binding_level;
1468
1469/* Insert SCOPE as the innermost binding level. */
1470
1471void
1472push_binding_level (cp_binding_level *scope)
1473{
1474 /* Add it to the front of currently active scopes stack. */
1475 scope->level_chain = current_binding_level;
1476 current_binding_level = scope;
1477 keep_next_level_flag = false;
1478
1479 if (ENABLE_SCOPE_CHECKING)
1480 {
1481 scope->binding_depth = binding_depth;
1482 indent (binding_depth);
1483 cp_binding_level_debug (scope, input_line, "push");
1484 binding_depth++;
1485 }
1486}
1487
1488/* Create a new KIND scope and make it the top of the active scopes stack.
1489 ENTITY is the scope of the associated C++ entity (namespace, class,
1490 function, C++0x enumeration); it is NULL otherwise. */
1491
1492cp_binding_level *
1493begin_scope (scope_kind kind, tree entity)
1494{
1495 cp_binding_level *scope;
1496
1497 /* Reuse or create a struct for this binding level. */
1498 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1499 {
1500 scope = free_binding_level;
1501 memset (scope, 0, sizeof (cp_binding_level));
1502 free_binding_level = scope->level_chain;
1503 }
1504 else
1505 scope = ggc_alloc_cleared_cp_binding_level ();
1506
1507 scope->this_entity = entity;
1508 scope->more_cleanups_ok = true;
1509 switch (kind)
1510 {
1511 case sk_cleanup:
1512 scope->keep = true;
1513 break;
1514
1515 case sk_template_spec:
1516 scope->explicit_spec_p = true;
1517 kind = sk_template_parms;
1518 /* Fall through. */
1519 case sk_template_parms:
1520 case sk_block:
1521 case sk_try:
1522 case sk_catch:
1523 case sk_for:
1524 case sk_cond:
1525 case sk_class:
1526 case sk_scoped_enum:
1527 case sk_function_parms:
1528 case sk_omp:
1529 scope->keep = keep_next_level_flag;
1530 break;
1531
1532 case sk_namespace:
1533 NAMESPACE_LEVEL (entity) = scope;
1534 scope->static_decls =
1535 VEC_alloc (tree, gc,
1536 DECL_NAME (entity) == std_identifier
1537 || DECL_NAME (entity) == global_scope_name
1538 ? 200 : 10);
1539 break;
1540
1541 default:
1542 /* Should not happen. */
1543 gcc_unreachable ();
1544 break;
1545 }
1546 scope->kind = kind;
1547
1548 push_binding_level (scope);
1549
1550 return scope;
1551}
1552
1553/* We're about to leave current scope. Pop the top of the stack of
1554 currently active scopes. Return the enclosing scope, now active. */
1555
1556cp_binding_level *
1557leave_scope (void)
1558{
1559 cp_binding_level *scope = current_binding_level;
1560
1561 if (scope->kind == sk_namespace && class_binding_level)
1562 current_binding_level = class_binding_level;
1563
1564 /* We cannot leave a scope, if there are none left. */
1565 if (NAMESPACE_LEVEL (global_namespace))
1566 gcc_assert (!global_scope_p (scope));
1567
1568 if (ENABLE_SCOPE_CHECKING)
1569 {
1570 indent (--binding_depth);
1571 cp_binding_level_debug (scope, input_line, "leave");
1572 }
1573
1574 /* Move one nesting level up. */
1575 current_binding_level = scope->level_chain;
1576
1577 /* Namespace-scopes are left most probably temporarily, not
1578 completely; they can be reopened later, e.g. in namespace-extension
1579 or any name binding activity that requires us to resume a
1580 namespace. For classes, we cache some binding levels. For other
1581 scopes, we just make the structure available for reuse. */
1582 if (scope->kind != sk_namespace
1583 && scope->kind != sk_class)
1584 {
1585 scope->level_chain = free_binding_level;
1586 gcc_assert (!ENABLE_SCOPE_CHECKING
1587 || scope->binding_depth == binding_depth);
1588 free_binding_level = scope;
1589 }
1590
1591 /* Find the innermost enclosing class scope, and reset
1592 CLASS_BINDING_LEVEL appropriately. */
1593 if (scope->kind == sk_class)
1594 {
1595 class_binding_level = NULL;
1596 for (scope = current_binding_level; scope; scope = scope->level_chain)
1597 if (scope->kind == sk_class)
1598 {
1599 class_binding_level = scope;
1600 break;
1601 }
1602 }
1603
1604 return current_binding_level;
1605}
1606
1607static void
1608resume_scope (cp_binding_level* b)
1609{
1610 /* Resuming binding levels is meant only for namespaces,
1611 and those cannot nest into classes. */
1612 gcc_assert (!class_binding_level);
1613 /* Also, resuming a non-directly nested namespace is a no-no. */
1614 gcc_assert (b->level_chain == current_binding_level);
1615 current_binding_level = b;
1616 if (ENABLE_SCOPE_CHECKING)
1617 {
1618 b->binding_depth = binding_depth;
1619 indent (binding_depth);
1620 cp_binding_level_debug (b, input_line, "resume");
1621 binding_depth++;
1622 }
1623}
1624
1625/* Return the innermost binding level that is not for a class scope. */
1626
1627static cp_binding_level *
1628innermost_nonclass_level (void)
1629{
1630 cp_binding_level *b;
1631
1632 b = current_binding_level;
1633 while (b->kind == sk_class)
1634 b = b->level_chain;
1635
1636 return b;
1637}
1638
1639/* We're defining an object of type TYPE. If it needs a cleanup, but
1640 we're not allowed to add any more objects with cleanups to the current
1641 scope, create a new binding level. */
1642
1643void
1644maybe_push_cleanup_level (tree type)
1645{
1646 if (type != error_mark_node
1647 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1648 && current_binding_level->more_cleanups_ok == 0)
1649 {
1650 begin_scope (sk_cleanup, NULL);
1651 current_binding_level->statement_list = push_stmt_list ();
1652 }
1653}
1654
1655/* Return true if we are in the global binding level. */
1656
1657bool
1658global_bindings_p (void)
1659{
1660 return global_scope_p (current_binding_level);
1661}
1662
1663/* True if we are currently in a toplevel binding level. This
1664 means either the global binding level or a namespace in a toplevel
1665 binding level. Since there are no non-toplevel namespace levels,
1666 this really means any namespace or template parameter level. We
1667 also include a class whose context is toplevel. */
1668
1669bool
1670toplevel_bindings_p (void)
1671{
1672 cp_binding_level *b = innermost_nonclass_level ();
1673
1674 return b->kind == sk_namespace || b->kind == sk_template_parms;
1675}
1676
1677/* True if this is a namespace scope, or if we are defining a class
1678 which is itself at namespace scope, or whose enclosing class is
1679 such a class, etc. */
1680
1681bool
1682namespace_bindings_p (void)
1683{
1684 cp_binding_level *b = innermost_nonclass_level ();
1685
1686 return b->kind == sk_namespace;
1687}
1688
1689/* True if the innermost non-class scope is a block scope. */
1690
1691bool
1692local_bindings_p (void)
1693{
1694 cp_binding_level *b = innermost_nonclass_level ();
1695 return b->kind < sk_function_parms || b->kind == sk_omp;
1696}
1697
1698/* True if the current level needs to have a BLOCK made. */
1699
1700bool
1701kept_level_p (void)
1702{
1703 return (current_binding_level->blocks != NULL_TREE
1704 || current_binding_level->keep
1705 || current_binding_level->kind == sk_cleanup
1706 || current_binding_level->names != NULL_TREE
1707 || current_binding_level->using_directives);
1708}
1709
1710/* Returns the kind of the innermost scope. */
1711
1712scope_kind
1713innermost_scope_kind (void)
1714{
1715 return current_binding_level->kind;
1716}
1717
1718/* Returns true if this scope was created to store template parameters. */
1719
1720bool
1721template_parm_scope_p (void)
1722{
1723 return innermost_scope_kind () == sk_template_parms;
1724}
1725
1726/* If KEEP is true, make a BLOCK node for the next binding level,
1727 unconditionally. Otherwise, use the normal logic to decide whether
1728 or not to create a BLOCK. */
1729
1730void
1731keep_next_level (bool keep)
1732{
1733 keep_next_level_flag = keep;
1734}
1735
1736/* Return the list of declarations of the current level.
1737 Note that this list is in reverse order unless/until
1738 you nreverse it; and when you do nreverse it, you must
1739 store the result back using `storedecls' or you will lose. */
1740
1741tree
1742getdecls (void)
1743{
1744 return current_binding_level->names;
1745}
1746
1747/* Return how many function prototypes we are currently nested inside. */
1748
1749int
1750function_parm_depth (void)
1751{
1752 int level = 0;
1753 cp_binding_level *b;
1754
1755 for (b = current_binding_level;
1756 b->kind == sk_function_parms;
1757 b = b->level_chain)
1758 ++level;
1759
1760 return level;
1761}
1762
1763/* For debugging. */
1764static int no_print_functions = 0;
1765static int no_print_builtins = 0;
1766
1767static void
1768print_binding_level (cp_binding_level* lvl)
1769{
1770 tree t;
1771 int i = 0, len;
1772 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1773 if (lvl->more_cleanups_ok)
1774 fprintf (stderr, " more-cleanups-ok");
1775 if (lvl->have_cleanups)
1776 fprintf (stderr, " have-cleanups");
1777 fprintf (stderr, "\n");
1778 if (lvl->names)
1779 {
1780 fprintf (stderr, " names:\t");
1781 /* We can probably fit 3 names to a line? */
1782 for (t = lvl->names; t; t = TREE_CHAIN (t))
1783 {
1784 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1785 continue;
1786 if (no_print_builtins
1787 && (TREE_CODE (t) == TYPE_DECL)
1788 && DECL_IS_BUILTIN (t))
1789 continue;
1790
1791 /* Function decls tend to have longer names. */
1792 if (TREE_CODE (t) == FUNCTION_DECL)
1793 len = 3;
1794 else
1795 len = 2;
1796 i += len;
1797 if (i > 6)
1798 {
1799 fprintf (stderr, "\n\t");
1800 i = len;
1801 }
1802 print_node_brief (stderr, "", t, 0);
1803 if (t == error_mark_node)
1804 break;
1805 }
1806 if (i)
1807 fprintf (stderr, "\n");
1808 }
1809 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1810 {
1811 size_t i;
1812 cp_class_binding *b;
1813 fprintf (stderr, " class-shadowed:");
1814 FOR_EACH_VEC_ELT (cp_class_binding, lvl->class_shadowed, i, b)
1815 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1816 fprintf (stderr, "\n");
1817 }
1818 if (lvl->type_shadowed)
1819 {
1820 fprintf (stderr, " type-shadowed:");
1821 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1822 {
1823 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1824 }
1825 fprintf (stderr, "\n");
1826 }
1827}
1828
1829void
1830print_other_binding_stack (cp_binding_level *stack)
1831{
1832 cp_binding_level *level;
1833 for (level = stack; !global_scope_p (level); level = level->level_chain)
1834 {
1835 fprintf (stderr, "binding level %p\n", (void *) level);
1836 print_binding_level (level);
1837 }
1838}
1839
1840void
1841print_binding_stack (void)
1842{
1843 cp_binding_level *b;
1844 fprintf (stderr, "current_binding_level=%p\n"
1845 "class_binding_level=%p\n"
1846 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1847 (void *) current_binding_level, (void *) class_binding_level,
1848 (void *) NAMESPACE_LEVEL (global_namespace));
1849 if (class_binding_level)
1850 {
1851 for (b = class_binding_level; b; b = b->level_chain)
1852 if (b == current_binding_level)
1853 break;
1854 if (b)
1855 b = class_binding_level;
1856 else
1857 b = current_binding_level;
1858 }
1859 else
1860 b = current_binding_level;
1861 print_other_binding_stack (b);
1862 fprintf (stderr, "global:\n");
1863 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1864}
1865\f
1866/* Return the type associated with ID. */
1867
1868static tree
1869identifier_type_value_1 (tree id)
1870{
1871 /* There is no type with that name, anywhere. */
1872 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1873 return NULL_TREE;
1874 /* This is not the type marker, but the real thing. */
1875 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1876 return REAL_IDENTIFIER_TYPE_VALUE (id);
1877 /* Have to search for it. It must be on the global level, now.
1878 Ask lookup_name not to return non-types. */
1879 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1880 if (id)
1881 return TREE_TYPE (id);
1882 return NULL_TREE;
1883}
1884
1885/* Wrapper for identifier_type_value_1. */
1886
1887tree
1888identifier_type_value (tree id)
1889{
1890 tree ret;
1891 timevar_start (TV_NAME_LOOKUP);
1892 ret = identifier_type_value_1 (id);
1893 timevar_stop (TV_NAME_LOOKUP);
1894 return ret;
1895}
1896
1897
1898/* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1899 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1900
1901tree
1902identifier_global_value (tree t)
1903{
1904 return IDENTIFIER_GLOBAL_VALUE (t);
1905}
1906
1907/* Push a definition of struct, union or enum tag named ID. into
1908 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1909 the tag ID is not already defined. */
1910
1911static void
1912set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
1913{
1914 tree type;
1915
1916 if (b->kind != sk_namespace)
1917 {
1918 /* Shadow the marker, not the real thing, so that the marker
1919 gets restored later. */
1920 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1921 b->type_shadowed
1922 = tree_cons (id, old_type_value, b->type_shadowed);
1923 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1924 TREE_TYPE (b->type_shadowed) = type;
1925 }
1926 else
1927 {
1928 cxx_binding *binding =
1929 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1930 gcc_assert (decl);
1931 if (binding->value)
1932 supplement_binding (binding, decl);
1933 else
1934 binding->value = decl;
1935
1936 /* Store marker instead of real type. */
1937 type = global_type_node;
1938 }
1939 SET_IDENTIFIER_TYPE_VALUE (id, type);
1940}
1941
1942/* As set_identifier_type_value_with_scope, but using
1943 current_binding_level. */
1944
1945void
1946set_identifier_type_value (tree id, tree decl)
1947{
1948 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1949}
1950
1951/* Return the name for the constructor (or destructor) for the
1952 specified class TYPE. When given a template, this routine doesn't
1953 lose the specialization. */
1954
1955static inline tree
1956constructor_name_full (tree type)
1957{
1958 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1959}
1960
1961/* Return the name for the constructor (or destructor) for the
1962 specified class. When given a template, return the plain
1963 unspecialized name. */
1964
1965tree
1966constructor_name (tree type)
1967{
1968 tree name;
1969 name = constructor_name_full (type);
1970 if (IDENTIFIER_TEMPLATE (name))
1971 name = IDENTIFIER_TEMPLATE (name);
1972 return name;
1973}
1974
1975/* Returns TRUE if NAME is the name for the constructor for TYPE,
1976 which must be a class type. */
1977
1978bool
1979constructor_name_p (tree name, tree type)
1980{
1981 tree ctor_name;
1982
1983 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1984
1985 if (!name)
1986 return false;
1987
1988 if (TREE_CODE (name) != IDENTIFIER_NODE)
1989 return false;
1990
1991 /* These don't have names. */
1992 if (TREE_CODE (type) == DECLTYPE_TYPE
1993 || TREE_CODE (type) == TYPEOF_TYPE)
1994 return false;
1995
1996 ctor_name = constructor_name_full (type);
1997 if (name == ctor_name)
1998 return true;
1999 if (IDENTIFIER_TEMPLATE (ctor_name)
2000 && name == IDENTIFIER_TEMPLATE (ctor_name))
2001 return true;
2002 return false;
2003}
2004
2005/* Counter used to create anonymous type names. */
2006
2007static GTY(()) int anon_cnt;
2008
2009/* Return an IDENTIFIER which can be used as a name for
2010 anonymous structs and unions. */
2011
2012tree
2013make_anon_name (void)
2014{
2015 char buf[32];
2016
2017 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2018 return get_identifier (buf);
2019}
2020
2021/* This code is practically identical to that for creating
2022 anonymous names, but is just used for lambdas instead. This is necessary
2023 because anonymous names are recognized and cannot be passed to template
2024 functions. */
2025/* FIXME is this still necessary? */
2026
2027static GTY(()) int lambda_cnt = 0;
2028
2029tree
2030make_lambda_name (void)
2031{
2032 char buf[32];
2033
2034 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
2035 return get_identifier (buf);
2036}
2037
2038/* Return (from the stack of) the BINDING, if any, established at SCOPE. */
2039
2040static inline cxx_binding *
2041find_binding (cp_binding_level *scope, cxx_binding *binding)
2042{
2043 for (; binding != NULL; binding = binding->previous)
2044 if (binding->scope == scope)
2045 return binding;
2046
2047 return (cxx_binding *)0;
2048}
2049
2050/* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
2051
2052static inline cxx_binding *
2053cp_binding_level_find_binding_for_name (cp_binding_level *scope, tree name)
2054{
2055 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2056 if (b)
2057 {
2058 /* Fold-in case where NAME is used only once. */
2059 if (scope == b->scope && b->previous == NULL)
2060 return b;
2061 return find_binding (scope, b);
2062 }
2063 return NULL;
2064}
2065
2066/* Always returns a binding for name in scope. If no binding is
2067 found, make a new one. */
2068
2069static cxx_binding *
2070binding_for_name (cp_binding_level *scope, tree name)
2071{
2072 cxx_binding *result;
2073
2074 result = cp_binding_level_find_binding_for_name (scope, name);
2075 if (result)
2076 return result;
2077 /* Not found, make a new one. */
2078 result = cxx_binding_make (NULL, NULL);
2079 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
2080 result->scope = scope;
2081 result->is_local = false;
2082 result->value_is_inherited = false;
2083 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2084 return result;
2085}
2086
2087/* Walk through the bindings associated to the name of FUNCTION,
2088 and return the first declaration of a function with a
2089 "C" linkage specification, a.k.a 'extern "C"'.
2090 This function looks for the binding, regardless of which scope it
2091 has been defined in. It basically looks in all the known scopes.
2092 Note that this function does not lookup for bindings of builtin functions
2093 or for functions declared in system headers. */
2094static tree
2095lookup_extern_c_fun_in_all_ns (tree function)
2096{
2097 tree name;
2098 cxx_binding *iter;
2099
2100 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
2101
2102 name = DECL_NAME (function);
2103 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
2104
2105 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2106 iter;
2107 iter = iter->previous)
2108 {
2109 tree ovl;
2110 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2111 {
2112 tree decl = OVL_CURRENT (ovl);
2113 if (decl
2114 && TREE_CODE (decl) == FUNCTION_DECL
2115 && DECL_EXTERN_C_P (decl)
2116 && !DECL_ARTIFICIAL (decl))
2117 {
2118 return decl;
2119 }
2120 }
2121 }
2122 return NULL;
2123}
2124
2125/* Returns a list of C-linkage decls with the name NAME. */
2126
2127tree
2128c_linkage_bindings (tree name)
2129{
2130 tree decls = NULL_TREE;
2131 cxx_binding *iter;
2132
2133 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2134 iter;
2135 iter = iter->previous)
2136 {
2137 tree ovl;
2138 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2139 {
2140 tree decl = OVL_CURRENT (ovl);
2141 if (decl
2142 && DECL_EXTERN_C_P (decl)
2143 && !DECL_ARTIFICIAL (decl))
2144 {
2145 if (decls == NULL_TREE)
2146 decls = decl;
2147 else
2148 decls = tree_cons (NULL_TREE, decl, decls);
2149 }
2150 }
2151 }
2152 return decls;
2153}
2154
2155/* Insert another USING_DECL into the current binding level, returning
2156 this declaration. If this is a redeclaration, do nothing, and
2157 return NULL_TREE if this not in namespace scope (in namespace
2158 scope, a using decl might extend any previous bindings). */
2159
2160static tree
2161push_using_decl_1 (tree scope, tree name)
2162{
2163 tree decl;
2164
2165 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
2166 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2167 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
2168 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
2169 break;
2170 if (decl)
2171 return namespace_bindings_p () ? decl : NULL_TREE;
2172 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
2173 USING_DECL_SCOPE (decl) = scope;
2174 DECL_CHAIN (decl) = current_binding_level->usings;
2175 current_binding_level->usings = decl;
2176 return decl;
2177}
2178
2179/* Wrapper for push_using_decl_1. */
2180
2181static tree
2182push_using_decl (tree scope, tree name)
2183{
2184 tree ret;
2185 timevar_start (TV_NAME_LOOKUP);
2186 ret = push_using_decl_1 (scope, name);
2187 timevar_stop (TV_NAME_LOOKUP);
2188 return ret;
2189}
2190
2191/* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2192 caller to set DECL_CONTEXT properly.
2193
2194 Note that this must only be used when X will be the new innermost
2195 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2196 without checking to see if the current IDENTIFIER_BINDING comes from a
2197 closer binding level than LEVEL. */
2198
2199static tree
2200pushdecl_with_scope_1 (tree x, cp_binding_level *level, bool is_friend)
2201{
2202 cp_binding_level *b;
2203 tree function_decl = current_function_decl;
2204
2205 current_function_decl = NULL_TREE;
2206 if (level->kind == sk_class)
2207 {
2208 b = class_binding_level;
2209 class_binding_level = level;
2210 pushdecl_class_level (x);
2211 class_binding_level = b;
2212 }
2213 else
2214 {
2215 b = current_binding_level;
2216 current_binding_level = level;
2217 x = pushdecl_maybe_friend (x, is_friend);
2218 current_binding_level = b;
2219 }
2220 current_function_decl = function_decl;
2221 return x;
2222}
2223
2224/* Wrapper for pushdecl_with_scope_1. */
2225
2226tree
2227pushdecl_with_scope (tree x, cp_binding_level *level, bool is_friend)
2228{
2229 tree ret;
2230 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2231 ret = pushdecl_with_scope_1 (x, level, is_friend);
2232 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2233 return ret;
2234}
2235
2236
2237/* DECL is a FUNCTION_DECL for a non-member function, which may have
2238 other definitions already in place. We get around this by making
2239 the value of the identifier point to a list of all the things that
2240 want to be referenced by that name. It is then up to the users of
2241 that name to decide what to do with that list.
2242
2243 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2244 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2245
2246 FLAGS is a bitwise-or of the following values:
2247 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2248 namespace scope.
2249 PUSH_USING: DECL is being pushed as the result of a using
2250 declaration.
2251
2252 IS_FRIEND is true if this is a friend declaration.
2253
2254 The value returned may be a previous declaration if we guessed wrong
2255 about what language DECL should belong to (C or C++). Otherwise,
2256 it's always DECL (and never something that's not a _DECL). */
2257
2258static tree
2259push_overloaded_decl_1 (tree decl, int flags, bool is_friend)
2260{
2261 tree name = DECL_NAME (decl);
2262 tree old;
2263 tree new_binding;
2264 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2265
2266 if (doing_global)
2267 old = namespace_binding (name, DECL_CONTEXT (decl));
2268 else
2269 old = lookup_name_innermost_nonclass_level (name);
2270
2271 if (old)
2272 {
2273 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2274 {
2275 tree t = TREE_TYPE (old);
2276 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2277 && (! DECL_IN_SYSTEM_HEADER (decl)
2278 || ! DECL_IN_SYSTEM_HEADER (old)))
2279 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2280 old = NULL_TREE;
2281 }
2282 else if (is_overloaded_fn (old))
2283 {
2284 tree tmp;
2285
2286 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2287 {
2288 tree fn = OVL_CURRENT (tmp);
2289 tree dup;
2290
2291 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2292 && !(flags & PUSH_USING)
2293 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2294 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2295 && ! decls_match (fn, decl))
2296 error ("%q#D conflicts with previous using declaration %q#D",
2297 decl, fn);
2298
2299 dup = duplicate_decls (decl, fn, is_friend);
2300 /* If DECL was a redeclaration of FN -- even an invalid
2301 one -- pass that information along to our caller. */
2302 if (dup == fn || dup == error_mark_node)
2303 return dup;
2304 }
2305
2306 /* We don't overload implicit built-ins. duplicate_decls()
2307 may fail to merge the decls if the new decl is e.g. a
2308 template function. */
2309 if (TREE_CODE (old) == FUNCTION_DECL
2310 && DECL_ANTICIPATED (old)
2311 && !DECL_HIDDEN_FRIEND_P (old))
2312 old = NULL;
2313 }
2314 else if (old == error_mark_node)
2315 /* Ignore the undefined symbol marker. */
2316 old = NULL_TREE;
2317 else
2318 {
2319 error ("previous non-function declaration %q+#D", old);
2320 error ("conflicts with function declaration %q#D", decl);
2321 return decl;
2322 }
2323 }
2324
2325 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2326 /* If it's a using declaration, we always need to build an OVERLOAD,
2327 because it's the only way to remember that the declaration comes
2328 from 'using', and have the lookup behave correctly. */
2329 || (flags & PUSH_USING))
2330 {
2331 if (old && TREE_CODE (old) != OVERLOAD)
2332 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2333 else
2334 new_binding = ovl_cons (decl, old);
2335 if (flags & PUSH_USING)
2336 OVL_USED (new_binding) = 1;
2337 }
2338 else
2339 /* NAME is not ambiguous. */
2340 new_binding = decl;
2341
2342 if (doing_global)
2343 set_namespace_binding (name, current_namespace, new_binding);
2344 else
2345 {
2346 /* We only create an OVERLOAD if there was a previous binding at
2347 this level, or if decl is a template. In the former case, we
2348 need to remove the old binding and replace it with the new
2349 binding. We must also run through the NAMES on the binding
2350 level where the name was bound to update the chain. */
2351
2352 if (TREE_CODE (new_binding) == OVERLOAD && old)
2353 {
2354 tree *d;
2355
2356 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2357 *d;
2358 d = &TREE_CHAIN (*d))
2359 if (*d == old
2360 || (TREE_CODE (*d) == TREE_LIST
2361 && TREE_VALUE (*d) == old))
2362 {
2363 if (TREE_CODE (*d) == TREE_LIST)
2364 /* Just replace the old binding with the new. */
2365 TREE_VALUE (*d) = new_binding;
2366 else
2367 /* Build a TREE_LIST to wrap the OVERLOAD. */
2368 *d = tree_cons (NULL_TREE, new_binding,
2369 TREE_CHAIN (*d));
2370
2371 /* And update the cxx_binding node. */
2372 IDENTIFIER_BINDING (name)->value = new_binding;
2373 return decl;
2374 }
2375
2376 /* We should always find a previous binding in this case. */
2377 gcc_unreachable ();
2378 }
2379
2380 /* Install the new binding. */
2381 push_local_binding (name, new_binding, flags);
2382 }
2383
2384 return decl;
2385}
2386
2387/* Wrapper for push_overloaded_decl_1. */
2388
2389static tree
2390push_overloaded_decl (tree decl, int flags, bool is_friend)
2391{
2392 tree ret;
2393 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2394 ret = push_overloaded_decl_1 (decl, flags, is_friend);
2395 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2396 return ret;
2397}
2398
2399/* Check a non-member using-declaration. Return the name and scope
2400 being used, and the USING_DECL, or NULL_TREE on failure. */
2401
2402static tree
2403validate_nonmember_using_decl (tree decl, tree scope, tree name)
2404{
2405 /* [namespace.udecl]
2406 A using-declaration for a class member shall be a
2407 member-declaration. */
2408 if (TYPE_P (scope))
2409 {
2410 error ("%qT is not a namespace", scope);
2411 return NULL_TREE;
2412 }
2413 else if (scope == error_mark_node)
2414 return NULL_TREE;
2415
2416 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2417 {
2418 /* 7.3.3/5
2419 A using-declaration shall not name a template-id. */
2420 error ("a using-declaration cannot specify a template-id. "
2421 "Try %<using %D%>", name);
2422 return NULL_TREE;
2423 }
2424
2425 if (TREE_CODE (decl) == NAMESPACE_DECL)
2426 {
2427 error ("namespace %qD not allowed in using-declaration", decl);
2428 return NULL_TREE;
2429 }
2430
2431 if (TREE_CODE (decl) == SCOPE_REF)
2432 {
2433 /* It's a nested name with template parameter dependent scope.
2434 This can only be using-declaration for class member. */
2435 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2436 return NULL_TREE;
2437 }
2438
2439 if (is_overloaded_fn (decl))
2440 decl = get_first_fn (decl);
2441
2442 gcc_assert (DECL_P (decl));
2443
2444 /* Make a USING_DECL. */
2445 return push_using_decl (scope, name);
2446}
2447
2448/* Process local and global using-declarations. */
2449
2450static void
2451do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2452 tree *newval, tree *newtype)
2453{
2454 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2455
2456 *newval = *newtype = NULL_TREE;
2457 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2458 /* Lookup error */
2459 return;
2460
2461 if (!decls.value && !decls.type)
2462 {
2463 error ("%qD not declared", name);
2464 return;
2465 }
2466
2467 /* Shift the old and new bindings around so we're comparing class and
2468 enumeration names to each other. */
2469 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2470 {
2471 oldtype = oldval;
2472 oldval = NULL_TREE;
2473 }
2474
2475 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2476 {
2477 decls.type = decls.value;
2478 decls.value = NULL_TREE;
2479 }
2480
2481 /* It is impossible to overload a built-in function; any explicit
2482 declaration eliminates the built-in declaration. So, if OLDVAL
2483 is a built-in, then we can just pretend it isn't there. */
2484 if (oldval
2485 && TREE_CODE (oldval) == FUNCTION_DECL
2486 && DECL_ANTICIPATED (oldval)
2487 && !DECL_HIDDEN_FRIEND_P (oldval))
2488 oldval = NULL_TREE;
2489
2490 if (decls.value)
2491 {
2492 /* Check for using functions. */
2493 if (is_overloaded_fn (decls.value))
2494 {
2495 tree tmp, tmp1;
2496
2497 if (oldval && !is_overloaded_fn (oldval))
2498 {
2499 error ("%qD is already declared in this scope", name);
2500 oldval = NULL_TREE;
2501 }
2502
2503 *newval = oldval;
2504 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2505 {
2506 tree new_fn = OVL_CURRENT (tmp);
2507
2508 /* [namespace.udecl]
2509
2510 If a function declaration in namespace scope or block
2511 scope has the same name and the same parameter types as a
2512 function introduced by a using declaration the program is
2513 ill-formed. */
2514 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2515 {
2516 tree old_fn = OVL_CURRENT (tmp1);
2517
2518 if (new_fn == old_fn)
2519 /* The function already exists in the current namespace. */
2520 break;
2521 else if (OVL_USED (tmp1))
2522 continue; /* this is a using decl */
2523 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2524 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2525 {
2526 gcc_assert (!DECL_ANTICIPATED (old_fn)
2527 || DECL_HIDDEN_FRIEND_P (old_fn));
2528
2529 /* There was already a non-using declaration in
2530 this scope with the same parameter types. If both
2531 are the same extern "C" functions, that's ok. */
2532 if (decls_match (new_fn, old_fn))
2533 break;
2534 else
2535 {
2536 error ("%qD is already declared in this scope", name);
2537 break;
2538 }
2539 }
2540 }
2541
2542 /* If we broke out of the loop, there's no reason to add
2543 this function to the using declarations for this
2544 scope. */
2545 if (tmp1)
2546 continue;
2547
2548 /* If we are adding to an existing OVERLOAD, then we no
2549 longer know the type of the set of functions. */
2550 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2551 TREE_TYPE (*newval) = unknown_type_node;
2552 /* Add this new function to the set. */
2553 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2554 /* If there is only one function, then we use its type. (A
2555 using-declaration naming a single function can be used in
2556 contexts where overload resolution cannot be
2557 performed.) */
2558 if (TREE_CODE (*newval) != OVERLOAD)
2559 {
2560 *newval = ovl_cons (*newval, NULL_TREE);
2561 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2562 }
2563 OVL_USED (*newval) = 1;
2564 }
2565 }
2566 else
2567 {
2568 *newval = decls.value;
2569 if (oldval && !decls_match (*newval, oldval))
2570 error ("%qD is already declared in this scope", name);
2571 }
2572 }
2573 else
2574 *newval = oldval;
2575
2576 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2577 {
2578 error ("reference to %qD is ambiguous", name);
2579 print_candidates (decls.type);
2580 }
2581 else
2582 {
2583 *newtype = decls.type;
2584 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2585 error ("%qD is already declared in this scope", name);
2586 }
2587
2588 /* If *newval is empty, shift any class or enumeration name down. */
2589 if (!*newval)
2590 {
2591 *newval = *newtype;
2592 *newtype = NULL_TREE;
2593 }
2594}
2595
2596/* Process a using-declaration at function scope. */
2597
2598void
2599do_local_using_decl (tree decl, tree scope, tree name)
2600{
2601 tree oldval, oldtype, newval, newtype;
2602 tree orig_decl = decl;
2603
2604 decl = validate_nonmember_using_decl (decl, scope, name);
2605 if (decl == NULL_TREE)
2606 return;
2607
2608 if (building_stmt_list_p ()
2609 && at_function_scope_p ())
2610 add_decl_expr (decl);
2611
2612 oldval = lookup_name_innermost_nonclass_level (name);
2613 oldtype = lookup_type_current_level (name);
2614
2615 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2616
2617 if (newval)
2618 {
2619 if (is_overloaded_fn (newval))
2620 {
2621 tree fn, term;
2622
2623 /* We only need to push declarations for those functions
2624 that were not already bound in the current level.
2625 The old value might be NULL_TREE, it might be a single
2626 function, or an OVERLOAD. */
2627 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2628 term = OVL_FUNCTION (oldval);
2629 else
2630 term = oldval;
2631 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2632 fn = OVL_NEXT (fn))
2633 push_overloaded_decl (OVL_CURRENT (fn),
2634 PUSH_LOCAL | PUSH_USING,
2635 false);
2636 }
2637 else
2638 push_local_binding (name, newval, PUSH_USING);
2639 }
2640 if (newtype)
2641 {
2642 push_local_binding (name, newtype, PUSH_USING);
2643 set_identifier_type_value (name, newtype);
2644 }
2645
2646 /* Emit debug info. */
2647 if (!processing_template_decl)
2648 cp_emit_debug_info_for_using (orig_decl, current_scope());
2649}
2650
2651/* Returns true if ROOT (a namespace, class, or function) encloses
2652 CHILD. CHILD may be either a class type or a namespace. */
2653
2654bool
2655is_ancestor (tree root, tree child)
2656{
2657 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2658 || TREE_CODE (root) == FUNCTION_DECL
2659 || CLASS_TYPE_P (root)));
2660 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2661 || CLASS_TYPE_P (child)));
2662
2663 /* The global namespace encloses everything. */
2664 if (root == global_namespace)
2665 return true;
2666
2667 while (true)
2668 {
2669 /* If we've run out of scopes, stop. */
2670 if (!child)
2671 return false;
2672 /* If we've reached the ROOT, it encloses CHILD. */
2673 if (root == child)
2674 return true;
2675 /* Go out one level. */
2676 if (TYPE_P (child))
2677 child = TYPE_NAME (child);
2678 child = DECL_CONTEXT (child);
2679 }
2680}
2681
2682/* Enter the class or namespace scope indicated by T suitable for name
2683 lookup. T can be arbitrary scope, not necessary nested inside the
2684 current scope. Returns a non-null scope to pop iff pop_scope
2685 should be called later to exit this scope. */
2686
2687tree
2688push_scope (tree t)
2689{
2690 if (TREE_CODE (t) == NAMESPACE_DECL)
2691 push_decl_namespace (t);
2692 else if (CLASS_TYPE_P (t))
2693 {
2694 if (!at_class_scope_p ()
2695 || !same_type_p (current_class_type, t))
2696 push_nested_class (t);
2697 else
2698 /* T is the same as the current scope. There is therefore no
2699 need to re-enter the scope. Since we are not actually
2700 pushing a new scope, our caller should not call
2701 pop_scope. */
2702 t = NULL_TREE;
2703 }
2704
2705 return t;
2706}
2707
2708/* Leave scope pushed by push_scope. */
2709
2710void
2711pop_scope (tree t)
2712{
2713 if (t == NULL_TREE)
2714 return;
2715 if (TREE_CODE (t) == NAMESPACE_DECL)
2716 pop_decl_namespace ();
2717 else if CLASS_TYPE_P (t)
2718 pop_nested_class ();
2719}
2720
2721/* Subroutine of push_inner_scope. */
2722
2723static void
2724push_inner_scope_r (tree outer, tree inner)
2725{
2726 tree prev;
2727
2728 if (outer == inner
2729 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2730 return;
2731
2732 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2733 if (outer != prev)
2734 push_inner_scope_r (outer, prev);
2735 if (TREE_CODE (inner) == NAMESPACE_DECL)
2736 {
2737 cp_binding_level *save_template_parm = 0;
2738 /* Temporary take out template parameter scopes. They are saved
2739 in reversed order in save_template_parm. */
2740 while (current_binding_level->kind == sk_template_parms)
2741 {
2742 cp_binding_level *b = current_binding_level;
2743 current_binding_level = b->level_chain;
2744 b->level_chain = save_template_parm;
2745 save_template_parm = b;
2746 }
2747
2748 resume_scope (NAMESPACE_LEVEL (inner));
2749 current_namespace = inner;
2750
2751 /* Restore template parameter scopes. */
2752 while (save_template_parm)
2753 {
2754 cp_binding_level *b = save_template_parm;
2755 save_template_parm = b->level_chain;
2756 b->level_chain = current_binding_level;
2757 current_binding_level = b;
2758 }
2759 }
2760 else
2761 pushclass (inner);
2762}
2763
2764/* Enter the scope INNER from current scope. INNER must be a scope
2765 nested inside current scope. This works with both name lookup and
2766 pushing name into scope. In case a template parameter scope is present,
2767 namespace is pushed under the template parameter scope according to
2768 name lookup rule in 14.6.1/6.
2769
2770 Return the former current scope suitable for pop_inner_scope. */
2771
2772tree
2773push_inner_scope (tree inner)
2774{
2775 tree outer = current_scope ();
2776 if (!outer)
2777 outer = current_namespace;
2778
2779 push_inner_scope_r (outer, inner);
2780 return outer;
2781}
2782
2783/* Exit the current scope INNER back to scope OUTER. */
2784
2785void
2786pop_inner_scope (tree outer, tree inner)
2787{
2788 if (outer == inner
2789 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2790 return;
2791
2792 while (outer != inner)
2793 {
2794 if (TREE_CODE (inner) == NAMESPACE_DECL)
2795 {
2796 cp_binding_level *save_template_parm = 0;
2797 /* Temporary take out template parameter scopes. They are saved
2798 in reversed order in save_template_parm. */
2799 while (current_binding_level->kind == sk_template_parms)
2800 {
2801 cp_binding_level *b = current_binding_level;
2802 current_binding_level = b->level_chain;
2803 b->level_chain = save_template_parm;
2804 save_template_parm = b;
2805 }
2806
2807 pop_namespace ();
2808
2809 /* Restore template parameter scopes. */
2810 while (save_template_parm)
2811 {
2812 cp_binding_level *b = save_template_parm;
2813 save_template_parm = b->level_chain;
2814 b->level_chain = current_binding_level;
2815 current_binding_level = b;
2816 }
2817 }
2818 else
2819 popclass ();
2820
2821 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2822 }
2823}
2824\f
2825/* Do a pushlevel for class declarations. */
2826
2827void
2828pushlevel_class (void)
2829{
2830 class_binding_level = begin_scope (sk_class, current_class_type);
2831}
2832
2833/* ...and a poplevel for class declarations. */
2834
2835void
2836poplevel_class (void)
2837{
2838 cp_binding_level *level = class_binding_level;
2839 cp_class_binding *cb;
2840 size_t i;
2841 tree shadowed;
2842
2843 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2844 gcc_assert (level != 0);
2845
2846 /* If we're leaving a toplevel class, cache its binding level. */
2847 if (current_class_depth == 1)
2848 previous_class_level = level;
2849 for (shadowed = level->type_shadowed;
2850 shadowed;
2851 shadowed = TREE_CHAIN (shadowed))
2852 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2853
2854 /* Remove the bindings for all of the class-level declarations. */
2855 if (level->class_shadowed)
2856 {
2857 FOR_EACH_VEC_ELT (cp_class_binding, level->class_shadowed, i, cb)
2858 {
2859 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
2860 cxx_binding_free (cb->base);
2861 }
2862 ggc_free (level->class_shadowed);
2863 level->class_shadowed = NULL;
2864 }
2865
2866 /* Now, pop out of the binding level which we created up in the
2867 `pushlevel_class' routine. */
2868 gcc_assert (current_binding_level == level);
2869 leave_scope ();
2870 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2871}
2872
2873/* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2874 appropriate. DECL is the value to which a name has just been
2875 bound. CLASS_TYPE is the class in which the lookup occurred. */
2876
2877static void
2878set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2879 tree class_type)
2880{
2881 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2882 {
2883 tree context;
2884
2885 if (TREE_CODE (decl) == OVERLOAD)
2886 context = ovl_scope (decl);
2887 else
2888 {
2889 gcc_assert (DECL_P (decl));
2890 context = context_for_name_lookup (decl);
2891 }
2892
2893 if (is_properly_derived_from (class_type, context))
2894 INHERITED_VALUE_BINDING_P (binding) = 1;
2895 else
2896 INHERITED_VALUE_BINDING_P (binding) = 0;
2897 }
2898 else if (binding->value == decl)
2899 /* We only encounter a TREE_LIST when there is an ambiguity in the
2900 base classes. Such an ambiguity can be overridden by a
2901 definition in this class. */
2902 INHERITED_VALUE_BINDING_P (binding) = 1;
2903 else
2904 INHERITED_VALUE_BINDING_P (binding) = 0;
2905}
2906
2907/* Make the declaration of X appear in CLASS scope. */
2908
2909bool
2910pushdecl_class_level (tree x)
2911{
2912 tree name;
2913 bool is_valid = true;
2914 bool subtime;
2915
2916 /* Do nothing if we're adding to an outer lambda closure type,
2917 outer_binding will add it later if it's needed. */
2918 if (current_class_type != class_binding_level->this_entity)
2919 return true;
2920
2921 subtime = timevar_cond_start (TV_NAME_LOOKUP);
2922 /* Get the name of X. */
2923 if (TREE_CODE (x) == OVERLOAD)
2924 name = DECL_NAME (get_first_fn (x));
2925 else
2926 name = DECL_NAME (x);
2927
2928 if (name)
2929 {
2930 is_valid = push_class_level_binding (name, x);
2931 if (TREE_CODE (x) == TYPE_DECL)
2932 set_identifier_type_value (name, x);
2933 }
2934 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2935 {
2936 /* If X is an anonymous aggregate, all of its members are
2937 treated as if they were members of the class containing the
2938 aggregate, for naming purposes. */
2939 tree f;
2940
2941 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = DECL_CHAIN (f))
2942 {
2943 location_t save_location = input_location;
2944 input_location = DECL_SOURCE_LOCATION (f);
2945 if (!pushdecl_class_level (f))
2946 is_valid = false;
2947 input_location = save_location;
2948 }
2949 }
2950 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2951 return is_valid;
2952}
2953
2954/* Return the BINDING (if any) for NAME in SCOPE, which is a class
2955 scope. If the value returned is non-NULL, and the PREVIOUS field
2956 is not set, callers must set the PREVIOUS field explicitly. */
2957
2958static cxx_binding *
2959get_class_binding (tree name, cp_binding_level *scope)
2960{
2961 tree class_type;
2962 tree type_binding;
2963 tree value_binding;
2964 cxx_binding *binding;
2965
2966 class_type = scope->this_entity;
2967
2968 /* Get the type binding. */
2969 type_binding = lookup_member (class_type, name,
2970 /*protect=*/2, /*want_type=*/true,
2971 tf_warning_or_error);
2972 /* Get the value binding. */
2973 value_binding = lookup_member (class_type, name,
2974 /*protect=*/2, /*want_type=*/false,
2975 tf_warning_or_error);
2976
2977 if (value_binding
2978 && (TREE_CODE (value_binding) == TYPE_DECL
2979 || DECL_CLASS_TEMPLATE_P (value_binding)
2980 || (TREE_CODE (value_binding) == TREE_LIST
2981 && TREE_TYPE (value_binding) == error_mark_node
2982 && (TREE_CODE (TREE_VALUE (value_binding))
2983 == TYPE_DECL))))
2984 /* We found a type binding, even when looking for a non-type
2985 binding. This means that we already processed this binding
2986 above. */
2987 ;
2988 else if (value_binding)
2989 {
2990 if (TREE_CODE (value_binding) == TREE_LIST
2991 && TREE_TYPE (value_binding) == error_mark_node)
2992 /* NAME is ambiguous. */
2993 ;
2994 else if (BASELINK_P (value_binding))
2995 /* NAME is some overloaded functions. */
2996 value_binding = BASELINK_FUNCTIONS (value_binding);
2997 }
2998
2999 /* If we found either a type binding or a value binding, create a
3000 new binding object. */
3001 if (type_binding || value_binding)
3002 {
3003 binding = new_class_binding (name,
3004 value_binding,
3005 type_binding,
3006 scope);
3007 /* This is a class-scope binding, not a block-scope binding. */
3008 LOCAL_BINDING_P (binding) = 0;
3009 set_inherited_value_binding_p (binding, value_binding, class_type);
3010 }
3011 else
3012 binding = NULL;
3013
3014 return binding;
3015}
3016
3017/* Make the declaration(s) of X appear in CLASS scope under the name
3018 NAME. Returns true if the binding is valid. */
3019
3020static bool
3021push_class_level_binding_1 (tree name, tree x)
3022{
3023 cxx_binding *binding;
3024 tree decl = x;
3025 bool ok;
3026
3027 /* The class_binding_level will be NULL if x is a template
3028 parameter name in a member template. */
3029 if (!class_binding_level)
3030 return true;
3031
3032 if (name == error_mark_node)
3033 return false;
3034
3035 /* Check for invalid member names. */
3036 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
3037 /* Check that we're pushing into the right binding level. */
3038 gcc_assert (current_class_type == class_binding_level->this_entity);
3039
3040 /* We could have been passed a tree list if this is an ambiguous
3041 declaration. If so, pull the declaration out because
3042 check_template_shadow will not handle a TREE_LIST. */
3043 if (TREE_CODE (decl) == TREE_LIST
3044 && TREE_TYPE (decl) == error_mark_node)
3045 decl = TREE_VALUE (decl);
3046
3047 if (!check_template_shadow (decl))
3048 return false;
3049
3050 /* [class.mem]
3051
3052 If T is the name of a class, then each of the following shall
3053 have a name different from T:
3054
3055 -- every static data member of class T;
3056
3057 -- every member of class T that is itself a type;
3058
3059 -- every enumerator of every member of class T that is an
3060 enumerated type;
3061
3062 -- every member of every anonymous union that is a member of
3063 class T.
3064
3065 (Non-static data members were also forbidden to have the same
3066 name as T until TC1.) */
3067 if ((TREE_CODE (x) == VAR_DECL
3068 || TREE_CODE (x) == CONST_DECL
3069 || (TREE_CODE (x) == TYPE_DECL
3070 && !DECL_SELF_REFERENCE_P (x))
3071 /* A data member of an anonymous union. */
3072 || (TREE_CODE (x) == FIELD_DECL
3073 && DECL_CONTEXT (x) != current_class_type))
3074 && DECL_NAME (x) == constructor_name (current_class_type))
3075 {
3076 tree scope = context_for_name_lookup (x);
3077 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
3078 {
3079 error ("%qD has the same name as the class in which it is "
3080 "declared",
3081 x);
3082 return false;
3083 }
3084 }
3085
3086 /* Get the current binding for NAME in this class, if any. */
3087 binding = IDENTIFIER_BINDING (name);
3088 if (!binding || binding->scope != class_binding_level)
3089 {
3090 binding = get_class_binding (name, class_binding_level);
3091 /* If a new binding was created, put it at the front of the
3092 IDENTIFIER_BINDING list. */
3093 if (binding)
3094 {
3095 binding->previous = IDENTIFIER_BINDING (name);
3096 IDENTIFIER_BINDING (name) = binding;
3097 }
3098 }
3099
3100 /* If there is already a binding, then we may need to update the
3101 current value. */
3102 if (binding && binding->value)
3103 {
3104 tree bval = binding->value;
3105 tree old_decl = NULL_TREE;
3106 tree target_decl = strip_using_decl (decl);
3107 tree target_bval = strip_using_decl (bval);
3108
3109 if (INHERITED_VALUE_BINDING_P (binding))
3110 {
3111 /* If the old binding was from a base class, and was for a
3112 tag name, slide it over to make room for the new binding.
3113 The old binding is still visible if explicitly qualified
3114 with a class-key. */
3115 if (TREE_CODE (target_bval) == TYPE_DECL
3116 && DECL_ARTIFICIAL (target_bval)
3117 && !(TREE_CODE (target_decl) == TYPE_DECL
3118 && DECL_ARTIFICIAL (target_decl)))
3119 {
3120 old_decl = binding->type;
3121 binding->type = bval;
3122 binding->value = NULL_TREE;
3123 INHERITED_VALUE_BINDING_P (binding) = 0;
3124 }
3125 else
3126 {
3127 old_decl = bval;
3128 /* Any inherited type declaration is hidden by the type
3129 declaration in the derived class. */
3130 if (TREE_CODE (target_decl) == TYPE_DECL
3131 && DECL_ARTIFICIAL (target_decl))
3132 binding->type = NULL_TREE;
3133 }
3134 }
3135 else if (TREE_CODE (target_decl) == OVERLOAD
3136 && is_overloaded_fn (target_bval))
3137 old_decl = bval;
3138 else if (TREE_CODE (decl) == USING_DECL
3139 && TREE_CODE (bval) == USING_DECL
3140 && same_type_p (USING_DECL_SCOPE (decl),
3141 USING_DECL_SCOPE (bval)))
3142 /* This is a using redeclaration that will be diagnosed later
3143 in supplement_binding */
3144 ;
3145 else if (TREE_CODE (decl) == USING_DECL
3146 && TREE_CODE (bval) == USING_DECL
3147 && DECL_DEPENDENT_P (decl)
3148 && DECL_DEPENDENT_P (bval))
3149 return true;
3150 else if (TREE_CODE (decl) == USING_DECL
3151 && is_overloaded_fn (target_bval))
3152 old_decl = bval;
3153 else if (TREE_CODE (bval) == USING_DECL
3154 && is_overloaded_fn (target_decl))
3155 return true;
3156
3157 if (old_decl && binding->scope == class_binding_level)
3158 {
3159 binding->value = x;
3160 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3161 here. This function is only used to register bindings
3162 from with the class definition itself. */
3163 INHERITED_VALUE_BINDING_P (binding) = 0;
3164 return true;
3165 }
3166 }
3167
3168 /* Note that we declared this value so that we can issue an error if
3169 this is an invalid redeclaration of a name already used for some
3170 other purpose. */
3171 note_name_declared_in_class (name, decl);
3172
3173 /* If we didn't replace an existing binding, put the binding on the
3174 stack of bindings for the identifier, and update the shadowed
3175 list. */
3176 if (binding && binding->scope == class_binding_level)
3177 /* Supplement the existing binding. */
3178 ok = supplement_binding (binding, decl);
3179 else
3180 {
3181 /* Create a new binding. */
3182 push_binding (name, decl, class_binding_level);
3183 ok = true;
3184 }
3185
3186 return ok;
3187}
3188
3189/* Wrapper for push_class_level_binding_1. */
3190
3191bool
3192push_class_level_binding (tree name, tree x)
3193{
3194 bool ret;
3195 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3196 ret = push_class_level_binding_1 (name, x);
3197 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3198 return ret;
3199}
3200
3201/* Process "using SCOPE::NAME" in a class scope. Return the
3202 USING_DECL created. */
3203
3204tree
3205do_class_using_decl (tree scope, tree name)
3206{
3207 /* The USING_DECL returned by this function. */
3208 tree value;
3209 /* The declaration (or declarations) name by this using
3210 declaration. NULL if we are in a template and cannot figure out
3211 what has been named. */
3212 tree decl;
3213 /* True if SCOPE is a dependent type. */
3214 bool scope_dependent_p;
3215 /* True if SCOPE::NAME is dependent. */
3216 bool name_dependent_p;
3217 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3218 bool bases_dependent_p;
3219 tree binfo;
3220 tree base_binfo;
3221 int i;
3222
3223 if (name == error_mark_node)
3224 return NULL_TREE;
3225
3226 if (!scope || !TYPE_P (scope))
3227 {
3228 error ("using-declaration for non-member at class scope");
3229 return NULL_TREE;
3230 }
3231
3232 /* Make sure the name is not invalid */
3233 if (TREE_CODE (name) == BIT_NOT_EXPR)
3234 {
3235 error ("%<%T::%D%> names destructor", scope, name);
3236 return NULL_TREE;
3237 }
3238 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
3239 {
3240 error ("%<%T::%D%> names constructor", scope, name);
3241 return NULL_TREE;
3242 }
3243 if (constructor_name_p (name, current_class_type))
3244 {
3245 error ("%<%T::%D%> names constructor in %qT",
3246 scope, name, current_class_type);
3247 return NULL_TREE;
3248 }
3249
3250 scope_dependent_p = dependent_scope_p (scope);
3251 name_dependent_p = (scope_dependent_p
3252 || (IDENTIFIER_TYPENAME_P (name)
3253 && dependent_type_p (TREE_TYPE (name))));
3254
3255 bases_dependent_p = false;
3256 if (processing_template_decl)
3257 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3258 BINFO_BASE_ITERATE (binfo, i, base_binfo);
3259 i++)
3260 if (dependent_type_p (TREE_TYPE (base_binfo)))
3261 {
3262 bases_dependent_p = true;
3263 break;
3264 }
3265
3266 decl = NULL_TREE;
3267
3268 /* From [namespace.udecl]:
3269
3270 A using-declaration used as a member-declaration shall refer to a
3271 member of a base class of the class being defined.
3272
3273 In general, we cannot check this constraint in a template because
3274 we do not know the entire set of base classes of the current
3275 class type. Morover, if SCOPE is dependent, it might match a
3276 non-dependent base. */
3277
3278 if (!scope_dependent_p)
3279 {
3280 base_kind b_kind;
3281 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
3282 if (b_kind < bk_proper_base)
3283 {
3284 if (!bases_dependent_p)
3285 {
3286 error_not_base_type (scope, current_class_type);
3287 return NULL_TREE;
3288 }
3289 }
3290 else if (!name_dependent_p)
3291 {
3292 decl = lookup_member (binfo, name, 0, false, tf_warning_or_error);
3293 if (!decl)
3294 {
3295 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3296 scope);
3297 return NULL_TREE;
3298 }
3299 /* The binfo from which the functions came does not matter. */
3300 if (BASELINK_P (decl))
3301 decl = BASELINK_FUNCTIONS (decl);
3302 }
3303 }
3304
3305 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3306 USING_DECL_DECLS (value) = decl;
3307 USING_DECL_SCOPE (value) = scope;
3308 DECL_DEPENDENT_P (value) = !decl;
3309
3310 return value;
3311}
3312
3313\f
3314/* Return the binding value for name in scope. */
3315
3316
3317static tree
3318namespace_binding_1 (tree name, tree scope)
3319{
3320 cxx_binding *binding;
3321
3322 if (SCOPE_FILE_SCOPE_P (scope))
3323 scope = global_namespace;
3324 else
3325 /* Unnecessary for the global namespace because it can't be an alias. */
3326 scope = ORIGINAL_NAMESPACE (scope);
3327
3328 binding = cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3329
3330 return binding ? binding->value : NULL_TREE;
3331}
3332
3333tree
3334namespace_binding (tree name, tree scope)
3335{
3336 tree ret;
3337 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3338 ret = namespace_binding_1 (name, scope);
3339 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3340 return ret;
3341}
3342
3343/* Set the binding value for name in scope. */
3344
3345static void
3346set_namespace_binding_1 (tree name, tree scope, tree val)
3347{
3348 cxx_binding *b;
3349
3350 if (scope == NULL_TREE)
3351 scope = global_namespace;
3352 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3353 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3354 b->value = val;
3355 else
3356 supplement_binding (b, val);
3357}
3358
3359/* Wrapper for set_namespace_binding_1. */
3360
3361void
3362set_namespace_binding (tree name, tree scope, tree val)
3363{
3364 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3365 set_namespace_binding_1 (name, scope, val);
3366 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3367}
3368
3369/* Set the context of a declaration to scope. Complain if we are not
3370 outside scope. */
3371
3372void
3373set_decl_namespace (tree decl, tree scope, bool friendp)
3374{
3375 tree old;
3376
3377 /* Get rid of namespace aliases. */
3378 scope = ORIGINAL_NAMESPACE (scope);
3379
3380 /* It is ok for friends to be qualified in parallel space. */
3381 if (!friendp && !is_ancestor (current_namespace, scope))
3382 error ("declaration of %qD not in a namespace surrounding %qD",
3383 decl, scope);
3384 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3385
3386 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3387 if (scope == current_namespace)
3388 {
3389 if (at_namespace_scope_p ())
3390 error ("explicit qualification in declaration of %qD",
3391 decl);
3392 return;
3393 }
3394
3395 /* See whether this has been declared in the namespace. */
3396 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3397 if (old == error_mark_node)
3398 /* No old declaration at all. */
3399 goto complain;
3400 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3401 if (TREE_CODE (old) == TREE_LIST)
3402 {
3403 error ("reference to %qD is ambiguous", decl);
3404 print_candidates (old);
3405 return;
3406 }
3407 if (!is_overloaded_fn (decl))
3408 {
3409 /* We might have found OLD in an inline namespace inside SCOPE. */
3410 if (TREE_CODE (decl) == TREE_CODE (old))
3411 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3412 /* Don't compare non-function decls with decls_match here, since
3413 it can't check for the correct constness at this
3414 point. pushdecl will find those errors later. */
3415 return;
3416 }
3417 /* Since decl is a function, old should contain a function decl. */
3418 if (!is_overloaded_fn (old))
3419 goto complain;
3420 /* A template can be explicitly specialized in any namespace. */
3421 if (processing_explicit_instantiation)
3422 return;
3423 if (processing_template_decl || processing_specialization)
3424 /* We have not yet called push_template_decl to turn a
3425 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3426 match. But, we'll check later, when we construct the
3427 template. */
3428 return;
3429 /* Instantiations or specializations of templates may be declared as
3430 friends in any namespace. */
3431 if (friendp && DECL_USE_TEMPLATE (decl))
3432 return;
3433 if (is_overloaded_fn (old))
3434 {
3435 tree found = NULL_TREE;
3436 tree elt = old;
3437 for (; elt; elt = OVL_NEXT (elt))
3438 {
3439 tree ofn = OVL_CURRENT (elt);
3440 /* Adjust DECL_CONTEXT first so decls_match will return true
3441 if DECL will match a declaration in an inline namespace. */
3442 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
3443 if (decls_match (decl, ofn))
3444 {
3445 if (found && !decls_match (found, ofn))
3446 {
3447 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3448 error ("reference to %qD is ambiguous", decl);
3449 print_candidates (old);
3450 return;
3451 }
3452 found = ofn;
3453 }
3454 }
3455 if (found)
3456 {
3457 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (found)))
3458 goto complain;
3459 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
3460 return;
3461 }
3462 }
3463 else
3464 {
3465 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3466 if (decls_match (decl, old))
3467 return;
3468 }
3469
3470 /* It didn't work, go back to the explicit scope. */
3471 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3472 complain:
3473 error ("%qD should have been declared inside %qD", decl, scope);
3474}
3475
3476/* Return the namespace where the current declaration is declared. */
3477
3478tree
3479current_decl_namespace (void)
3480{
3481 tree result;
3482 /* If we have been pushed into a different namespace, use it. */
3483 if (!VEC_empty (tree, decl_namespace_list))
3484 return VEC_last (tree, decl_namespace_list);
3485
3486 if (current_class_type)
3487 result = decl_namespace_context (current_class_type);
3488 else if (current_function_decl)
3489 result = decl_namespace_context (current_function_decl);
3490 else
3491 result = current_namespace;
3492 return result;
3493}
3494
3495/* Process any ATTRIBUTES on a namespace definition. Currently only
3496 attribute visibility is meaningful, which is a property of the syntactic
3497 block rather than the namespace as a whole, so we don't touch the
3498 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3499
3500bool
3501handle_namespace_attrs (tree ns, tree attributes)
3502{
3503 tree d;
3504 bool saw_vis = false;
3505
3506 for (d = attributes; d; d = TREE_CHAIN (d))
3507 {
3508 tree name = TREE_PURPOSE (d);
3509 tree args = TREE_VALUE (d);
3510
3511 if (is_attribute_p ("visibility", name))
3512 {
3513 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3514 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3515 {
3516 warning (OPT_Wattributes,
3517 "%qD attribute requires a single NTBS argument",
3518 name);
3519 continue;
3520 }
3521
3522 if (!TREE_PUBLIC (ns))
3523 warning (OPT_Wattributes,
3524 "%qD attribute is meaningless since members of the "
3525 "anonymous namespace get local symbols", name);
3526
3527 push_visibility (TREE_STRING_POINTER (x), 1);
3528 saw_vis = true;
3529 }
3530 else
3531 {
3532 warning (OPT_Wattributes, "%qD attribute directive ignored",
3533 name);
3534 continue;
3535 }
3536 }
3537
3538 return saw_vis;
3539}
3540
3541/* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3542 select a name that is unique to this compilation unit. */
3543
3544void
3545push_namespace (tree name)
3546{
3547 tree d = NULL_TREE;
3548 int need_new = 1;
3549 int implicit_use = 0;
3550 bool anon = !name;
3551
3552 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3553
3554 /* We should not get here if the global_namespace is not yet constructed
3555 nor if NAME designates the global namespace: The global scope is
3556 constructed elsewhere. */
3557 gcc_assert (global_namespace != NULL && name != global_scope_name);
3558
3559 if (anon)
3560 {
3561 name = get_anonymous_namespace_name();
3562 d = IDENTIFIER_NAMESPACE_VALUE (name);
3563 if (d)
3564 /* Reopening anonymous namespace. */
3565 need_new = 0;
3566 implicit_use = 1;
3567 }
3568 else
3569 {
3570 /* Check whether this is an extended namespace definition. */
3571 d = IDENTIFIER_NAMESPACE_VALUE (name);
3572 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3573 {
3574 need_new = 0;
3575 if (DECL_NAMESPACE_ALIAS (d))
3576 {
3577 error ("namespace alias %qD not allowed here, assuming %qD",
3578 d, DECL_NAMESPACE_ALIAS (d));
3579 d = DECL_NAMESPACE_ALIAS (d);
3580 }
3581 }
3582 }
3583
3584 if (need_new)
3585 {
3586 /* Make a new namespace, binding the name to it. */
3587 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3588 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3589 /* The name of this namespace is not visible to other translation
3590 units if it is an anonymous namespace or member thereof. */
3591 if (anon || decl_anon_ns_mem_p (current_namespace))
3592 TREE_PUBLIC (d) = 0;
3593 else
3594 TREE_PUBLIC (d) = 1;
3595 pushdecl (d);
3596 if (anon)
3597 {
3598 /* Clear DECL_NAME for the benefit of debugging back ends. */
3599 SET_DECL_ASSEMBLER_NAME (d, name);
3600 DECL_NAME (d) = NULL_TREE;
3601 }
3602 begin_scope (sk_namespace, d);
3603 }
3604 else
3605 resume_scope (NAMESPACE_LEVEL (d));
3606
3607 if (implicit_use)
3608 do_using_directive (d);
3609 /* Enter the name space. */
3610 current_namespace = d;
3611
3612 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3613}
3614
3615/* Pop from the scope of the current namespace. */
3616
3617void
3618pop_namespace (void)
3619{
3620 gcc_assert (current_namespace != global_namespace);
3621 current_namespace = CP_DECL_CONTEXT (current_namespace);
3622 /* The binding level is not popped, as it might be re-opened later. */
3623 leave_scope ();
3624}
3625
3626/* Push into the scope of the namespace NS, even if it is deeply
3627 nested within another namespace. */
3628
3629void
3630push_nested_namespace (tree ns)
3631{
3632 if (ns == global_namespace)
3633 push_to_top_level ();
3634 else
3635 {
3636 push_nested_namespace (CP_DECL_CONTEXT (ns));
3637 push_namespace (DECL_NAME (ns));
3638 }
3639}
3640
3641/* Pop back from the scope of the namespace NS, which was previously
3642 entered with push_nested_namespace. */
3643
3644void
3645pop_nested_namespace (tree ns)
3646{
3647 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3648 gcc_assert (current_namespace == ns);
3649 while (ns != global_namespace)
3650 {
3651 pop_namespace ();
3652 ns = CP_DECL_CONTEXT (ns);
3653 }
3654
3655 pop_from_top_level ();
3656 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3657}
3658
3659/* Temporarily set the namespace for the current declaration. */
3660
3661void
3662push_decl_namespace (tree decl)
3663{
3664 if (TREE_CODE (decl) != NAMESPACE_DECL)
3665 decl = decl_namespace_context (decl);
3666 VEC_safe_push (tree, gc, decl_namespace_list, ORIGINAL_NAMESPACE (decl));
3667}
3668
3669/* [namespace.memdef]/2 */
3670
3671void
3672pop_decl_namespace (void)
3673{
3674 VEC_pop (tree, decl_namespace_list);
3675}
3676
3677/* Return the namespace that is the common ancestor
3678 of two given namespaces. */
3679
3680static tree
3681namespace_ancestor_1 (tree ns1, tree ns2)
3682{
3683 tree nsr;
3684 if (is_ancestor (ns1, ns2))
3685 nsr = ns1;
3686 else
3687 nsr = namespace_ancestor_1 (CP_DECL_CONTEXT (ns1), ns2);
3688 return nsr;
3689}
3690
3691/* Wrapper for namespace_ancestor_1. */
3692
3693static tree
3694namespace_ancestor (tree ns1, tree ns2)
3695{
3696 tree nsr;
3697 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3698 nsr = namespace_ancestor_1 (ns1, ns2);
3699 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3700 return nsr;
3701}
3702
3703/* Process a namespace-alias declaration. */
3704
3705void
3706do_namespace_alias (tree alias, tree name_space)
3707{
3708 if (name_space == error_mark_node)
3709 return;
3710
3711 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3712
3713 name_space = ORIGINAL_NAMESPACE (name_space);
3714
3715 /* Build the alias. */
3716 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3717 DECL_NAMESPACE_ALIAS (alias) = name_space;
3718 DECL_EXTERNAL (alias) = 1;
3719 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3720 pushdecl (alias);
3721
3722 /* Emit debug info for namespace alias. */
3723 if (!building_stmt_list_p ())
3724 (*debug_hooks->global_decl) (alias);
3725}
3726
3727/* Like pushdecl, only it places X in the current namespace,
3728 if appropriate. */
3729
3730tree
3731pushdecl_namespace_level (tree x, bool is_friend)
3732{
3733 cp_binding_level *b = current_binding_level;
3734 tree t;
3735
3736 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3737 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3738
3739 /* Now, the type_shadowed stack may screw us. Munge it so it does
3740 what we want. */
3741 if (TREE_CODE (t) == TYPE_DECL)
3742 {
3743 tree name = DECL_NAME (t);
3744 tree newval;
3745 tree *ptr = (tree *)0;
3746 for (; !global_scope_p (b); b = b->level_chain)
3747 {
3748 tree shadowed = b->type_shadowed;