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