OSDN Git Service

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