OSDN Git Service

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