OSDN Git Service

PR c++/41090
[pf3gnuchains/gcc-fork.git] / gcc / cp / decl.c
1 /* Process declarations and variables for C++ compiler.
2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4    Free Software Foundation, Inc.
5    Contributed by Michael Tiemann (tiemann@cygnus.com)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23
24 /* Process declarations and symbol lookup for C++ front end.
25    Also constructs types; the standard scalar types at initialization,
26    and structure, union, array and enum types when they are declared.  */
27
28 /* ??? not all decl nodes are given the most useful possible
29    line numbers.  For example, the CONST_DECLs for enum values.  */
30
31 #include "config.h"
32 #include "system.h"
33 #include "coretypes.h"
34 #include "tm.h"
35 #include "tree.h"
36 #include "rtl.h"
37 #include "expr.h"
38 #include "flags.h"
39 #include "cp-tree.h"
40 #include "tree-inline.h"
41 #include "decl.h"
42 #include "intl.h"
43 #include "output.h"
44 #include "except.h"
45 #include "toplev.h"
46 #include "hashtab.h"
47 #include "tm_p.h"
48 #include "target.h"
49 #include "c-common.h"
50 #include "c-pragma.h"
51 #include "diagnostic.h"
52 #include "intl.h"
53 #include "debug.h"
54 #include "timevar.h"
55 #include "tree-flow.h"
56 #include "pointer-set.h"
57 #include "plugin.h"
58
59 static tree grokparms (tree parmlist, tree *);
60 static const char *redeclaration_error_message (tree, tree);
61
62 static int decl_jump_unsafe (tree);
63 static void require_complete_types_for_parms (tree);
64 static int ambi_op_p (enum tree_code);
65 static int unary_op_p (enum tree_code);
66 static void push_local_name (tree);
67 static tree grok_reference_init (tree, tree, tree, tree *);
68 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
69                          int, int, tree);
70 static void record_unknown_type (tree, const char *);
71 static tree builtin_function_1 (tree, tree, bool);
72 static tree build_library_fn_1 (tree, enum tree_code, tree);
73 static int member_function_or_else (tree, tree, enum overload_flags);
74 static void bad_specifiers (tree, const char *, int, int, int, int,
75                             int);
76 static void check_for_uninitialized_const_var (tree);
77 static hashval_t typename_hash (const void *);
78 static int typename_compare (const void *, const void *);
79 static tree local_variable_p_walkfn (tree *, int *, void *);
80 static tree record_builtin_java_type (const char *, int);
81 static const char *tag_name (enum tag_types);
82 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
83 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
84 static void maybe_deduce_size_from_array_init (tree, tree);
85 static void layout_var_decl (tree);
86 static tree check_initializer (tree, tree, int, tree *);
87 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
88 static void save_function_data (tree);
89 static void check_function_type (tree, tree);
90 static void finish_constructor_body (void);
91 static void begin_destructor_body (void);
92 static void finish_destructor_body (void);
93 static tree create_array_type_for_decl (tree, tree, tree);
94 static tree get_atexit_node (void);
95 static tree get_dso_handle_node (void);
96 static tree start_cleanup_fn (void);
97 static void end_cleanup_fn (void);
98 static tree cp_make_fname_decl (location_t, tree, int);
99 static void initialize_predefined_identifiers (void);
100 static tree check_special_function_return_type
101         (special_function_kind, tree, tree);
102 static tree push_cp_library_fn (enum tree_code, tree);
103 static tree build_cp_library_fn (tree, enum tree_code, tree);
104 static void store_parm_decls (tree);
105 static void initialize_local_var (tree, tree);
106 static void expand_static_init (tree, tree);
107 static tree next_initializable_field (tree);
108
109 /* The following symbols are subsumed in the cp_global_trees array, and
110    listed here individually for documentation purposes.
111
112    C++ extensions
113         tree wchar_decl_node;
114
115         tree vtable_entry_type;
116         tree delta_type_node;
117         tree __t_desc_type_node;
118
119         tree class_type_node;
120         tree unknown_type_node;
121
122    Array type `vtable_entry_type[]'
123
124         tree vtbl_type_node;
125         tree vtbl_ptr_type_node;
126
127    Namespaces,
128
129         tree std_node;
130         tree abi_node;
131
132    A FUNCTION_DECL which can call `abort'.  Not necessarily the
133    one that the user will declare, but sufficient to be called
134    by routines that want to abort the program.
135
136         tree abort_fndecl;
137
138    The FUNCTION_DECL for the default `::operator delete'.
139
140         tree global_delete_fndecl;
141
142    Used by RTTI
143         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
144         tree tinfo_var_id;  */
145
146 tree cp_global_trees[CPTI_MAX];
147
148 /* Indicates that there is a type value in some namespace, although
149    that is not necessarily in scope at the moment.  */
150
151 tree global_type_node;
152
153 /* The node that holds the "name" of the global scope.  */
154 tree global_scope_name;
155
156 #define local_names cp_function_chain->x_local_names
157
158 /* A list of objects which have constructors or destructors
159    which reside in the global scope.  The decl is stored in
160    the TREE_VALUE slot and the initializer is stored
161    in the TREE_PURPOSE slot.  */
162 tree static_aggregates;
163
164 /* -- end of C++ */
165
166 /* A node for the integer constants 2, and 3.  */
167
168 tree integer_two_node, integer_three_node;
169
170 /* Used only for jumps to as-yet undefined labels, since jumps to
171    defined labels can have their validity checked immediately.  */
172
173 struct GTY(()) named_label_use_entry {
174   struct named_label_use_entry *next;
175   /* The binding level to which this entry is *currently* attached.
176      This is initially the binding level in which the goto appeared,
177      but is modified as scopes are closed.  */
178   struct cp_binding_level *binding_level;
179   /* The head of the names list that was current when the goto appeared,
180      or the inner scope popped.  These are the decls that will *not* be
181      skipped when jumping to the label.  */
182   tree names_in_scope;
183   /* The location of the goto, for error reporting.  */
184   location_t o_goto_locus;
185   /* True if an OpenMP structured block scope has been closed since
186      the goto appeared.  This means that the branch from the label will
187      illegally exit an OpenMP scope.  */
188   bool in_omp_scope;
189 };
190
191 /* A list of all LABEL_DECLs in the function that have names.  Here so
192    we can clear out their names' definitions at the end of the
193    function, and so we can check the validity of jumps to these labels.  */
194
195 struct GTY(()) named_label_entry {
196   /* The decl itself.  */
197   tree label_decl;
198
199   /* The binding level to which the label is *currently* attached.
200      This is initially set to the binding level in which the label
201      is defined, but is modified as scopes are closed.  */
202   struct cp_binding_level *binding_level;
203   /* The head of the names list that was current when the label was
204      defined, or the inner scope popped.  These are the decls that will
205      be skipped when jumping to the label.  */
206   tree names_in_scope;
207   /* A tree list of all decls from all binding levels that would be
208      crossed by a backward branch to the label.  */
209   tree bad_decls;
210
211   /* A list of uses of the label, before the label is defined.  */
212   struct named_label_use_entry *uses;
213
214   /* The following bits are set after the label is defined, and are
215      updated as scopes are popped.  They indicate that a backward jump
216      to the label will illegally enter a scope of the given flavor.  */
217   bool in_try_scope;
218   bool in_catch_scope;
219   bool in_omp_scope;
220 };
221
222 #define named_labels cp_function_chain->x_named_labels
223 \f
224 /* The number of function bodies which we are currently processing.
225    (Zero if we are at namespace scope, one inside the body of a
226    function, two inside the body of a function in a local class, etc.)  */
227 int function_depth;
228
229 /* To avoid unwanted recursion, finish_function defers all mark_used calls
230    encountered during its execution until it finishes.  */
231 bool defer_mark_used_calls;
232 VEC(tree, gc) *deferred_mark_used_calls;
233
234 /* States indicating how grokdeclarator() should handle declspecs marked
235    with __attribute__((deprecated)).  An object declared as
236    __attribute__((deprecated)) suppresses warnings of uses of other
237    deprecated items.  */
238 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
239
240 \f
241 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
242    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
243    time the VAR_DECL was declared, the type was incomplete.  */
244
245 static GTY(()) tree incomplete_vars;
246 \f
247 /* Returns the kind of template specialization we are currently
248    processing, given that it's declaration contained N_CLASS_SCOPES
249    explicit scope qualifications.  */
250
251 tmpl_spec_kind
252 current_tmpl_spec_kind (int n_class_scopes)
253 {
254   int n_template_parm_scopes = 0;
255   int seen_specialization_p = 0;
256   int innermost_specialization_p = 0;
257   struct cp_binding_level *b;
258
259   /* Scan through the template parameter scopes.  */
260   for (b = current_binding_level;
261        b->kind == sk_template_parms;
262        b = b->level_chain)
263     {
264       /* If we see a specialization scope inside a parameter scope,
265          then something is wrong.  That corresponds to a declaration
266          like:
267
268             template <class T> template <> ...
269
270          which is always invalid since [temp.expl.spec] forbids the
271          specialization of a class member template if the enclosing
272          class templates are not explicitly specialized as well.  */
273       if (b->explicit_spec_p)
274         {
275           if (n_template_parm_scopes == 0)
276             innermost_specialization_p = 1;
277           else
278             seen_specialization_p = 1;
279         }
280       else if (seen_specialization_p == 1)
281         return tsk_invalid_member_spec;
282
283       ++n_template_parm_scopes;
284     }
285
286   /* Handle explicit instantiations.  */
287   if (processing_explicit_instantiation)
288     {
289       if (n_template_parm_scopes != 0)
290         /* We've seen a template parameter list during an explicit
291            instantiation.  For example:
292
293              template <class T> template void f(int);
294
295            This is erroneous.  */
296         return tsk_invalid_expl_inst;
297       else
298         return tsk_expl_inst;
299     }
300
301   if (n_template_parm_scopes < n_class_scopes)
302     /* We've not seen enough template headers to match all the
303        specialized classes present.  For example:
304
305          template <class T> void R<T>::S<T>::f(int);
306
307        This is invalid; there needs to be one set of template
308        parameters for each class.  */
309     return tsk_insufficient_parms;
310   else if (n_template_parm_scopes == n_class_scopes)
311     /* We're processing a non-template declaration (even though it may
312        be a member of a template class.)  For example:
313
314          template <class T> void S<T>::f(int);
315
316        The `class T' matches the `S<T>', leaving no template headers
317        corresponding to the `f'.  */
318     return tsk_none;
319   else if (n_template_parm_scopes > n_class_scopes + 1)
320     /* We've got too many template headers.  For example:
321
322          template <> template <class T> void f (T);
323
324        There need to be more enclosing classes.  */
325     return tsk_excessive_parms;
326   else
327     /* This must be a template.  It's of the form:
328
329          template <class T> template <class U> void S<T>::f(U);
330
331        This is a specialization if the innermost level was a
332        specialization; otherwise it's just a definition of the
333        template.  */
334     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
335 }
336
337 /* Exit the current scope.  */
338
339 void
340 finish_scope (void)
341 {
342   poplevel (0, 0, 0);
343 }
344
345 /* When a label goes out of scope, check to see if that label was used
346    in a valid manner, and issue any appropriate warnings or errors.  */
347
348 static void
349 pop_label (tree label, tree old_value)
350 {
351   if (!processing_template_decl)
352     {
353       if (DECL_INITIAL (label) == NULL_TREE)
354         {
355           location_t location;
356
357           error ("label %q+D used but not defined", label);
358           location = input_location; /* FIXME want (input_filename, (line)0) */
359           /* Avoid crashing later.  */
360           define_label (location, DECL_NAME (label));
361         }
362       else 
363         warn_for_unused_label (label);
364     }
365
366   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
367 }
368
369 /* At the end of a function, all labels declared within the function
370    go out of scope.  BLOCK is the top-level block for the
371    function.  */
372
373 static int
374 pop_labels_1 (void **slot, void *data)
375 {
376   struct named_label_entry *ent = (struct named_label_entry *) *slot;
377   tree block = (tree) data;
378
379   pop_label (ent->label_decl, NULL_TREE);
380
381   /* Put the labels into the "variables" of the top-level block,
382      so debugger can see them.  */
383   TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
384   BLOCK_VARS (block) = ent->label_decl;
385
386   htab_clear_slot (named_labels, slot);
387
388   return 1;
389 }
390
391 static void
392 pop_labels (tree block)
393 {
394   if (named_labels)
395     {
396       htab_traverse (named_labels, pop_labels_1, block);
397       named_labels = NULL;
398     }
399 }
400
401 /* At the end of a block with local labels, restore the outer definition.  */
402
403 static void
404 pop_local_label (tree label, tree old_value)
405 {
406   struct named_label_entry dummy;
407   void **slot;
408
409   pop_label (label, old_value);
410
411   dummy.label_decl = label;
412   slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
413   htab_clear_slot (named_labels, slot);
414 }
415
416 /* The following two routines are used to interface to Objective-C++.
417    The binding level is purposely treated as an opaque type.  */
418
419 void *
420 objc_get_current_scope (void)
421 {
422   return current_binding_level;
423 }
424
425 /* The following routine is used by the NeXT-style SJLJ exceptions;
426    variables get marked 'volatile' so as to not be clobbered by
427    _setjmp()/_longjmp() calls.  All variables in the current scope,
428    as well as parent scopes up to (but not including) ENCLOSING_BLK
429    shall be thusly marked.  */
430
431 void
432 objc_mark_locals_volatile (void *enclosing_blk)
433 {
434   struct cp_binding_level *scope;
435
436   for (scope = current_binding_level;
437        scope && scope != enclosing_blk;
438        scope = scope->level_chain)
439     {
440       tree decl;
441
442       for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
443         objc_volatilize_decl (decl);
444
445       /* Do not climb up past the current function.  */
446       if (scope->kind == sk_function_parms)
447         break;
448     }
449 }
450
451 /* Update data for defined and undefined labels when leaving a scope.  */
452
453 static int
454 poplevel_named_label_1 (void **slot, void *data)
455 {
456   struct named_label_entry *ent = (struct named_label_entry *) *slot;
457   struct cp_binding_level *bl = (struct cp_binding_level *) data;
458   struct cp_binding_level *obl = bl->level_chain;
459
460   if (ent->binding_level == bl)
461     {
462       tree decl;
463
464       for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
465         if (decl_jump_unsafe (decl))
466           ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
467
468       ent->binding_level = obl;
469       ent->names_in_scope = obl->names;
470       switch (bl->kind)
471         {
472         case sk_try:
473           ent->in_try_scope = true;
474           break;
475         case sk_catch:
476           ent->in_catch_scope = true;
477           break;
478         case sk_omp:
479           ent->in_omp_scope = true;
480           break;
481         default:
482           break;
483         }
484     }
485   else if (ent->uses)
486     {
487       struct named_label_use_entry *use;
488
489       for (use = ent->uses; use ; use = use->next)
490         if (use->binding_level == bl)
491           {
492             use->binding_level = obl;
493             use->names_in_scope = obl->names;
494             if (bl->kind == sk_omp)
495               use->in_omp_scope = true;
496           }
497     }
498
499   return 1;
500 }
501
502 /* Exit a binding level.
503    Pop the level off, and restore the state of the identifier-decl mappings
504    that were in effect when this level was entered.
505
506    If KEEP == 1, this level had explicit declarations, so
507    and create a "block" (a BLOCK node) for the level
508    to record its declarations and subblocks for symbol table output.
509
510    If FUNCTIONBODY is nonzero, this level is the body of a function,
511    so create a block as if KEEP were set and also clear out all
512    label names.
513
514    If REVERSE is nonzero, reverse the order of decls before putting
515    them into the BLOCK.  */
516
517 tree
518 poplevel (int keep, int reverse, int functionbody)
519 {
520   tree link;
521   /* The chain of decls was accumulated in reverse order.
522      Put it into forward order, just for cleanliness.  */
523   tree decls;
524   tree subblocks;
525   tree block;
526   tree decl;
527   int leaving_for_scope;
528   scope_kind kind;
529
530   timevar_push (TV_NAME_LOOKUP);
531  restart:
532
533   block = NULL_TREE;
534
535   gcc_assert (current_binding_level->kind != sk_class);
536
537   if (current_binding_level->kind == sk_cleanup)
538     functionbody = 0;
539   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
540
541   gcc_assert (!VEC_length(cp_class_binding,
542                           current_binding_level->class_shadowed));
543
544   /* We used to use KEEP == 2 to indicate that the new block should go
545      at the beginning of the list of blocks at this binding level,
546      rather than the end.  This hack is no longer used.  */
547   gcc_assert (keep == 0 || keep == 1);
548
549   if (current_binding_level->keep)
550     keep = 1;
551
552   /* Any uses of undefined labels, and any defined labels, now operate
553      under constraints of next binding contour.  */
554   if (cfun && !functionbody && named_labels)
555     htab_traverse (named_labels, poplevel_named_label_1,
556                    current_binding_level);
557
558   /* Get the decls in the order they were written.
559      Usually current_binding_level->names is in reverse order.
560      But parameter decls were previously put in forward order.  */
561
562   if (reverse)
563     current_binding_level->names
564       = decls = nreverse (current_binding_level->names);
565   else
566     decls = current_binding_level->names;
567
568   /* If there were any declarations or structure tags in that level,
569      or if this level is a function body,
570      create a BLOCK to record them for the life of this function.  */
571   block = NULL_TREE;
572   if (keep == 1 || functionbody)
573     block = make_node (BLOCK);
574   if (block != NULL_TREE)
575     {
576       BLOCK_VARS (block) = decls;
577       BLOCK_SUBBLOCKS (block) = subblocks;
578     }
579
580   /* In each subblock, record that this is its superior.  */
581   if (keep >= 0)
582     for (link = subblocks; link; link = BLOCK_CHAIN (link))
583       BLOCK_SUPERCONTEXT (link) = block;
584
585   /* We still support the old for-scope rules, whereby the variables
586      in a for-init statement were in scope after the for-statement
587      ended.  We only use the new rules if flag_new_for_scope is
588      nonzero.  */
589   leaving_for_scope
590     = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
591
592   /* Before we remove the declarations first check for unused variables.  */
593   if (warn_unused_variable
594       && !processing_template_decl)
595     for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
596       if (TREE_CODE (decl) == VAR_DECL
597           && ! TREE_USED (decl)
598           && ! DECL_IN_SYSTEM_HEADER (decl)
599           && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
600         warning (OPT_Wunused_variable, "unused variable %q+D", decl);
601
602   /* Remove declarations for all the DECLs in this level.  */
603   for (link = decls; link; link = TREE_CHAIN (link))
604     {
605       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
606           && DECL_NAME (link))
607         {
608           tree name = DECL_NAME (link);
609           cxx_binding *ob;
610           tree ns_binding;
611
612           ob = outer_binding (name,
613                               IDENTIFIER_BINDING (name),
614                               /*class_p=*/true);
615           if (!ob)
616             ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
617           else
618             ns_binding = NULL_TREE;
619
620           if (ob && ob->scope == current_binding_level->level_chain)
621             /* We have something like:
622
623                  int i;
624                  for (int i; ;);
625
626                and we are leaving the `for' scope.  There's no reason to
627                keep the binding of the inner `i' in this case.  */
628             pop_binding (name, link);
629           else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
630                    || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
631             /* Here, we have something like:
632
633                  typedef int I;
634
635                  void f () {
636                    for (int I; ;);
637                  }
638
639                We must pop the for-scope binding so we know what's a
640                type and what isn't.  */
641             pop_binding (name, link);
642           else
643             {
644               /* Mark this VAR_DECL as dead so that we can tell we left it
645                  there only for backward compatibility.  */
646               DECL_DEAD_FOR_LOCAL (link) = 1;
647
648               /* Keep track of what should have happened when we
649                  popped the binding.  */
650               if (ob && ob->value)
651                 {
652                   SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
653                   DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
654                 }
655
656               /* Add it to the list of dead variables in the next
657                  outermost binding to that we can remove these when we
658                  leave that binding.  */
659               current_binding_level->level_chain->dead_vars_from_for
660                 = tree_cons (NULL_TREE, link,
661                              current_binding_level->level_chain->
662                              dead_vars_from_for);
663
664               /* Although we don't pop the cxx_binding, we do clear
665                  its SCOPE since the scope is going away now.  */
666               IDENTIFIER_BINDING (name)->scope
667                 = current_binding_level->level_chain;
668             }
669         }
670       else
671         {
672           tree name;
673
674           /* Remove the binding.  */
675           decl = link;
676
677           if (TREE_CODE (decl) == TREE_LIST)
678             decl = TREE_VALUE (decl);
679           name = decl;
680
681           if (TREE_CODE (name) == OVERLOAD)
682             name = OVL_FUNCTION (name);
683
684           gcc_assert (DECL_P (name));
685           pop_binding (DECL_NAME (name), decl);
686         }
687     }
688
689   /* Remove declarations for any `for' variables from inner scopes
690      that we kept around.  */
691   for (link = current_binding_level->dead_vars_from_for;
692        link; link = TREE_CHAIN (link))
693     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
694
695   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
696   for (link = current_binding_level->type_shadowed;
697        link; link = TREE_CHAIN (link))
698     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
699
700   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
701   for (link = current_binding_level->shadowed_labels;
702        link;
703        link = TREE_CHAIN (link))
704     pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
705
706   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
707      list if a `using' declaration put them there.  The debugging
708      back ends won't understand OVERLOAD, so we remove them here.
709      Because the BLOCK_VARS are (temporarily) shared with
710      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
711      popped all the bindings.  */
712   if (block)
713     {
714       tree* d;
715
716       for (d = &BLOCK_VARS (block); *d; )
717         {
718           if (TREE_CODE (*d) == TREE_LIST)
719             *d = TREE_CHAIN (*d);
720           else
721             d = &TREE_CHAIN (*d);
722         }
723     }
724
725   /* If the level being exited is the top level of a function,
726      check over all the labels.  */
727   if (functionbody)
728     {
729       /* Since this is the top level block of a function, the vars are
730          the function's parameters.  Don't leave them in the BLOCK
731          because they are found in the FUNCTION_DECL instead.  */
732       BLOCK_VARS (block) = 0;
733       pop_labels (block);
734     }
735
736   kind = current_binding_level->kind;
737   if (kind == sk_cleanup)
738     {
739       tree stmt;
740
741       /* If this is a temporary binding created for a cleanup, then we'll
742          have pushed a statement list level.  Pop that, create a new
743          BIND_EXPR for the block, and insert it into the stream.  */
744       stmt = pop_stmt_list (current_binding_level->statement_list);
745       stmt = c_build_bind_expr (input_location, block, stmt);
746       add_stmt (stmt);
747     }
748
749   leave_scope ();
750   if (functionbody)
751     {
752       /* The current function is being defined, so its DECL_INITIAL
753          should be error_mark_node.  */
754       gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
755       DECL_INITIAL (current_function_decl) = block;
756     }
757   else if (block)
758     current_binding_level->blocks
759       = chainon (current_binding_level->blocks, block);
760
761   /* If we did not make a block for the level just exited,
762      any blocks made for inner levels
763      (since they cannot be recorded as subblocks in that level)
764      must be carried forward so they will later become subblocks
765      of something else.  */
766   else if (subblocks)
767     current_binding_level->blocks
768       = chainon (current_binding_level->blocks, subblocks);
769
770   /* Each and every BLOCK node created here in `poplevel' is important
771      (e.g. for proper debugging information) so if we created one
772      earlier, mark it as "used".  */
773   if (block)
774     TREE_USED (block) = 1;
775
776   /* All temporary bindings created for cleanups are popped silently.  */
777   if (kind == sk_cleanup)
778     goto restart;
779
780   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
781 }
782
783 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
784    itself, calling F for each.  The DATA is passed to F as well.  */
785
786 static int
787 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
788 {
789   int result = 0;
790   tree current = NAMESPACE_LEVEL (name_space)->namespaces;
791
792   result |= (*f) (name_space, data);
793
794   for (; current; current = TREE_CHAIN (current))
795     result |= walk_namespaces_r (current, f, data);
796
797   return result;
798 }
799
800 /* Walk all the namespaces, calling F for each.  The DATA is passed to
801    F as well.  */
802
803 int
804 walk_namespaces (walk_namespaces_fn f, void* data)
805 {
806   return walk_namespaces_r (global_namespace, f, data);
807 }
808
809 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
810    DATA is non-NULL, this is the last time we will call
811    wrapup_global_declarations for this NAMESPACE.  */
812
813 int
814 wrapup_globals_for_namespace (tree name_space, void* data)
815 {
816   struct cp_binding_level *level = NAMESPACE_LEVEL (name_space);
817   VEC(tree,gc) *statics = level->static_decls;
818   tree *vec = VEC_address (tree, statics);
819   int len = VEC_length (tree, statics);
820   int last_time = (data != 0);
821
822   if (last_time)
823     {
824       check_global_declarations (vec, len);
825       emit_debug_global_declarations (vec, len);
826       return 0;
827     }
828
829   /* Write out any globals that need to be output.  */
830   return wrapup_global_declarations (vec, len);
831 }
832
833 \f
834 /* In C++, you don't have to write `struct S' to refer to `S'; you
835    can just use `S'.  We accomplish this by creating a TYPE_DECL as
836    if the user had written `typedef struct S S'.  Create and return
837    the TYPE_DECL for TYPE.  */
838
839 tree
840 create_implicit_typedef (tree name, tree type)
841 {
842   tree decl;
843
844   decl = build_decl (input_location, TYPE_DECL, name, type);
845   DECL_ARTIFICIAL (decl) = 1;
846   /* There are other implicit type declarations, like the one *within*
847      a class that allows you to write `S::S'.  We must distinguish
848      amongst these.  */
849   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
850   TYPE_NAME (type) = decl;
851   TYPE_STUB_DECL (type) = decl;
852
853   return decl;
854 }
855
856 /* Remember a local name for name-mangling purposes.  */
857
858 static void
859 push_local_name (tree decl)
860 {
861   size_t i, nelts;
862   tree t, name;
863
864   timevar_push (TV_NAME_LOOKUP);
865
866   name = DECL_NAME (decl);
867
868   nelts = VEC_length (tree, local_names);
869   for (i = 0; i < nelts; i++)
870     {
871       t = VEC_index (tree, local_names, i);
872       if (DECL_NAME (t) == name)
873         {
874           if (!DECL_LANG_SPECIFIC (decl))
875             retrofit_lang_decl (decl);
876           DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1;
877           if (DECL_LANG_SPECIFIC (t))
878             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
879           else
880             DECL_DISCRIMINATOR (decl) = 1;
881
882           VEC_replace (tree, local_names, i, decl);
883           timevar_pop (TV_NAME_LOOKUP);
884           return;
885         }
886     }
887
888   VEC_safe_push (tree, gc, local_names, decl);
889   timevar_pop (TV_NAME_LOOKUP);
890 }
891 \f
892 /* Subroutine of duplicate_decls: return truthvalue of whether
893    or not types of these decls match.
894
895    For C++, we must compare the parameter list so that `int' can match
896    `int&' in a parameter position, but `int&' is not confused with
897    `const int&'.  */
898
899 int
900 decls_match (tree newdecl, tree olddecl)
901 {
902   int types_match;
903
904   if (newdecl == olddecl)
905     return 1;
906
907   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
908     /* If the two DECLs are not even the same kind of thing, we're not
909        interested in their types.  */
910     return 0;
911
912   if (TREE_CODE (newdecl) == FUNCTION_DECL)
913     {
914       tree f1 = TREE_TYPE (newdecl);
915       tree f2 = TREE_TYPE (olddecl);
916       tree p1 = TYPE_ARG_TYPES (f1);
917       tree p2 = TYPE_ARG_TYPES (f2);
918
919       /* Specializations of different templates are different functions
920          even if they have the same type.  */
921       tree t1 = (DECL_USE_TEMPLATE (newdecl)
922                  ? DECL_TI_TEMPLATE (newdecl)
923                  : NULL_TREE);
924       tree t2 = (DECL_USE_TEMPLATE (olddecl)
925                  ? DECL_TI_TEMPLATE (olddecl)
926                  : NULL_TREE);
927       if (t1 != t2)
928         return 0;
929
930       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
931           && ! (DECL_EXTERN_C_P (newdecl)
932                 && DECL_EXTERN_C_P (olddecl)))
933         return 0;
934
935 #ifdef NO_IMPLICIT_EXTERN_C
936       /* A new declaration doesn't match a built-in one unless it
937          is also extern "C".  */
938       if (DECL_IS_BUILTIN (olddecl)
939           && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl))
940         return 0;
941 #endif
942
943       if (TREE_CODE (f1) != TREE_CODE (f2))
944         return 0;
945
946       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
947         {
948           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
949               && (DECL_BUILT_IN (olddecl)
950 #ifndef NO_IMPLICIT_EXTERN_C
951                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
952                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
953 #endif
954               ))
955             {
956               types_match = self_promoting_args_p (p1);
957               if (p1 == void_list_node)
958                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
959             }
960 #ifndef NO_IMPLICIT_EXTERN_C
961           else if (p1 == NULL_TREE
962                    && (DECL_EXTERN_C_P (olddecl)
963                        && DECL_IN_SYSTEM_HEADER (olddecl)
964                        && !DECL_CLASS_SCOPE_P (olddecl))
965                    && (DECL_EXTERN_C_P (newdecl)
966                        && DECL_IN_SYSTEM_HEADER (newdecl)
967                        && !DECL_CLASS_SCOPE_P (newdecl)))
968             {
969               types_match = self_promoting_args_p (p2);
970               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
971             }
972 #endif
973           else
974             types_match = compparms (p1, p2);
975         }
976       else
977         types_match = 0;
978     }
979   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
980     {
981       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
982           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
983         return 0;
984
985       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
986                                 DECL_TEMPLATE_PARMS (olddecl)))
987         return 0;
988
989       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
990         types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
991                                    TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
992       else
993         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
994                                    DECL_TEMPLATE_RESULT (newdecl));
995     }
996   else
997     {
998       /* Need to check scope for variable declaration (VAR_DECL).
999          For typedef (TYPE_DECL), scope is ignored.  */
1000       if (TREE_CODE (newdecl) == VAR_DECL
1001           && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1002           /* [dcl.link]
1003              Two declarations for an object with C language linkage
1004              with the same name (ignoring the namespace that qualify
1005              it) that appear in different namespace scopes refer to
1006              the same object.  */
1007           && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1008         return 0;
1009
1010       if (TREE_TYPE (newdecl) == error_mark_node)
1011         types_match = TREE_TYPE (olddecl) == error_mark_node;
1012       else if (TREE_TYPE (olddecl) == NULL_TREE)
1013         types_match = TREE_TYPE (newdecl) == NULL_TREE;
1014       else if (TREE_TYPE (newdecl) == NULL_TREE)
1015         types_match = 0;
1016       else
1017         types_match = comptypes (TREE_TYPE (newdecl),
1018                                  TREE_TYPE (olddecl),
1019                                  COMPARE_REDECLARATION);
1020     }
1021
1022   return types_match;
1023 }
1024
1025 /* If NEWDECL is `static' and an `extern' was seen previously,
1026    warn about it.  OLDDECL is the previous declaration.
1027
1028    Note that this does not apply to the C++ case of declaring
1029    a variable `extern const' and then later `const'.
1030
1031    Don't complain about built-in functions, since they are beyond
1032    the user's control.  */
1033
1034 void
1035 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1036 {
1037   if (TREE_CODE (newdecl) == TYPE_DECL
1038       || TREE_CODE (newdecl) == TEMPLATE_DECL
1039       || TREE_CODE (newdecl) == CONST_DECL
1040       || TREE_CODE (newdecl) == NAMESPACE_DECL)
1041     return;
1042
1043   /* Don't get confused by static member functions; that's a different
1044      use of `static'.  */
1045   if (TREE_CODE (newdecl) == FUNCTION_DECL
1046       && DECL_STATIC_FUNCTION_P (newdecl))
1047     return;
1048
1049   /* If the old declaration was `static', or the new one isn't, then
1050      then everything is OK.  */
1051   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1052     return;
1053
1054   /* It's OK to declare a builtin function as `static'.  */
1055   if (TREE_CODE (olddecl) == FUNCTION_DECL
1056       && DECL_ARTIFICIAL (olddecl))
1057     return;
1058
1059   permerror (input_location, "%qD was declared %<extern%> and later %<static%>", newdecl);
1060   permerror (input_location, "previous declaration of %q+D", olddecl);
1061 }
1062
1063 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1064    function templates.  If their exception specifications do not
1065    match, issue a diagnostic.  */
1066
1067 static void
1068 check_redeclaration_exception_specification (tree new_decl,
1069                                              tree old_decl)
1070 {
1071   tree new_type;
1072   tree old_type;
1073   tree new_exceptions;
1074   tree old_exceptions;
1075
1076   new_type = TREE_TYPE (new_decl);
1077   new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1078   old_type = TREE_TYPE (old_decl);
1079   old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1080
1081   /* [except.spec]
1082
1083      If any declaration of a function has an exception-specification,
1084      all declarations, including the definition and an explicit
1085      specialization, of that function shall have an
1086      exception-specification with the same set of type-ids.  */
1087   if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1088       && ! DECL_IS_BUILTIN (old_decl)
1089       && flag_exceptions
1090       && !comp_except_specs (new_exceptions, old_exceptions,
1091                              /*exact=*/true))
1092     {
1093       error ("declaration of %qF throws different exceptions", new_decl);
1094       error ("from previous declaration %q+F", old_decl);
1095     }
1096 }
1097
1098 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn)                   \
1099                           && lookup_attribute ("gnu_inline",            \
1100                                                DECL_ATTRIBUTES (fn)))
1101
1102 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1103    If the redeclaration is invalid, a diagnostic is issued, and the
1104    error_mark_node is returned.  Otherwise, OLDDECL is returned.
1105
1106    If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1107    returned.
1108
1109    NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend.  */
1110
1111 tree
1112 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1113 {
1114   unsigned olddecl_uid = DECL_UID (olddecl);
1115   int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1116   int new_defines_function = 0;
1117   tree new_template_info;
1118
1119   if (newdecl == olddecl)
1120     return olddecl;
1121
1122   types_match = decls_match (newdecl, olddecl);
1123
1124   /* If either the type of the new decl or the type of the old decl is an
1125      error_mark_node, then that implies that we have already issued an
1126      error (earlier) for some bogus type specification, and in that case,
1127      it is rather pointless to harass the user with yet more error message
1128      about the same declaration, so just pretend the types match here.  */
1129   if (TREE_TYPE (newdecl) == error_mark_node
1130       || TREE_TYPE (olddecl) == error_mark_node)
1131     return error_mark_node;
1132
1133   if (DECL_P (olddecl)
1134       && TREE_CODE (newdecl) == FUNCTION_DECL
1135       && TREE_CODE (olddecl) == FUNCTION_DECL
1136       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1137     {
1138       if (DECL_DECLARED_INLINE_P (newdecl)
1139           && DECL_UNINLINABLE (newdecl)
1140           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1141         /* Already warned elsewhere.  */;
1142       else if (DECL_DECLARED_INLINE_P (olddecl)
1143                && DECL_UNINLINABLE (olddecl)
1144                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1145         /* Already warned.  */;
1146       else if (DECL_DECLARED_INLINE_P (newdecl)
1147                && DECL_UNINLINABLE (olddecl)
1148                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1149         {
1150           warning (OPT_Wattributes, "function %q+D redeclared as inline",
1151                    newdecl);
1152           warning (OPT_Wattributes, "previous declaration of %q+D "
1153                    "with attribute noinline", olddecl);
1154         }
1155       else if (DECL_DECLARED_INLINE_P (olddecl)
1156                && DECL_UNINLINABLE (newdecl)
1157                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1158         {
1159           warning (OPT_Wattributes, "function %q+D redeclared with "
1160                    "attribute noinline", newdecl);
1161           warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1162                    olddecl);
1163         }
1164     }
1165
1166   /* Check for redeclaration and other discrepancies.  */
1167   if (TREE_CODE (olddecl) == FUNCTION_DECL
1168       && DECL_ARTIFICIAL (olddecl))
1169     {
1170       gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1171       if (TREE_CODE (newdecl) != FUNCTION_DECL)
1172         {
1173           /* Avoid warnings redeclaring built-ins which have not been
1174              explicitly declared.  */
1175           if (DECL_ANTICIPATED (olddecl))
1176             return NULL_TREE;
1177
1178           /* If you declare a built-in or predefined function name as static,
1179              the old definition is overridden, but optionally warn this was a
1180              bad choice of name.  */
1181           if (! TREE_PUBLIC (newdecl))
1182             {
1183               warning (OPT_Wshadow, 
1184                        DECL_BUILT_IN (olddecl)
1185                        ? G_("shadowing built-in function %q#D")
1186                        : G_("shadowing library function %q#D"), olddecl);
1187               /* Discard the old built-in function.  */
1188               return NULL_TREE;
1189             }
1190           /* If the built-in is not ansi, then programs can override
1191              it even globally without an error.  */
1192           else if (! DECL_BUILT_IN (olddecl))
1193             warning (0, "library function %q#D redeclared as non-function %q#D",
1194                      olddecl, newdecl);
1195           else
1196             {
1197               error ("declaration of %q#D", newdecl);
1198               error ("conflicts with built-in declaration %q#D",
1199                      olddecl);
1200             }
1201           return NULL_TREE;
1202         }
1203       else if (!types_match)
1204         {
1205           /* Avoid warnings redeclaring built-ins which have not been
1206              explicitly declared.  */
1207           if (DECL_ANTICIPATED (olddecl))
1208             {
1209               /* Deal with fileptr_type_node.  FILE type is not known
1210                  at the time we create the builtins.  */
1211               tree t1, t2;
1212
1213               for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1214                    t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1215                    t1 || t2;
1216                    t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1217                 if (!t1 || !t2)
1218                   break;
1219                 else if (TREE_VALUE (t2) == fileptr_type_node)
1220                   {
1221                     tree t = TREE_VALUE (t1);
1222
1223                     if (TREE_CODE (t) == POINTER_TYPE
1224                         && TYPE_NAME (TREE_TYPE (t))
1225                         && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1226                            == get_identifier ("FILE")
1227                         && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1228                       {
1229                         tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1230
1231                         TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1232                           = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1233                         types_match = decls_match (newdecl, olddecl);
1234                         if (types_match)
1235                           return duplicate_decls (newdecl, olddecl,
1236                                                   newdecl_is_friend);
1237                         TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1238                       }
1239                   }
1240                 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1241                   break;
1242             }
1243           else if ((DECL_EXTERN_C_P (newdecl)
1244                     && DECL_EXTERN_C_P (olddecl))
1245                    || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1246                                  TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1247             {
1248               /* A near match; override the builtin.  */
1249
1250               if (TREE_PUBLIC (newdecl))
1251                 {
1252                   warning (0, "new declaration %q#D", newdecl);
1253                   warning (0, "ambiguates built-in declaration %q#D",
1254                            olddecl);
1255                 }
1256               else
1257                 warning (OPT_Wshadow, 
1258                          DECL_BUILT_IN (olddecl)
1259                          ? G_("shadowing built-in function %q#D")
1260                          : G_("shadowing library function %q#D"), olddecl);
1261             }
1262           else
1263             /* Discard the old built-in function.  */
1264             return NULL_TREE;
1265
1266           /* Replace the old RTL to avoid problems with inlining.  */
1267           COPY_DECL_RTL (newdecl, olddecl);
1268         }
1269       /* Even if the types match, prefer the new declarations type for
1270          built-ins which have not been explicitly declared, for
1271          exception lists, etc...  */
1272       else if (DECL_ANTICIPATED (olddecl))
1273         {
1274           tree type = TREE_TYPE (newdecl);
1275           tree attribs = (*targetm.merge_type_attributes)
1276             (TREE_TYPE (olddecl), type);
1277
1278           type = cp_build_type_attribute_variant (type, attribs);
1279           TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1280         }
1281
1282       /* If a function is explicitly declared "throw ()", propagate that to
1283          the corresponding builtin.  */
1284       if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1285           && DECL_ANTICIPATED (olddecl)
1286           && TREE_NOTHROW (newdecl)
1287           && !TREE_NOTHROW (olddecl)
1288           && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != NULL_TREE
1289           && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != olddecl
1290           && types_match)
1291         TREE_NOTHROW (built_in_decls [DECL_FUNCTION_CODE (olddecl)]) = 1;
1292
1293       /* Whether or not the builtin can throw exceptions has no
1294          bearing on this declarator.  */
1295       TREE_NOTHROW (olddecl) = 0;
1296
1297       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1298         {
1299           /* If a builtin function is redeclared as `static', merge
1300              the declarations, but make the original one static.  */
1301           DECL_THIS_STATIC (olddecl) = 1;
1302           TREE_PUBLIC (olddecl) = 0;
1303
1304           /* Make the old declaration consistent with the new one so
1305              that all remnants of the builtin-ness of this function
1306              will be banished.  */
1307           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1308           COPY_DECL_RTL (newdecl, olddecl);
1309         }
1310     }
1311   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1312     {
1313       /* C++ Standard, 3.3, clause 4:
1314          "[Note: a namespace name or a class template name must be unique
1315          in its declarative region (7.3.2, clause 14). ]"  */
1316       if (TREE_CODE (olddecl) != NAMESPACE_DECL
1317           && TREE_CODE (newdecl) != NAMESPACE_DECL
1318           && (TREE_CODE (olddecl) != TEMPLATE_DECL
1319               || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1320           && (TREE_CODE (newdecl) != TEMPLATE_DECL
1321               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1322         {
1323           if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1324                && TREE_CODE (newdecl) != TYPE_DECL)
1325               || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1326                   && TREE_CODE (olddecl) != TYPE_DECL))
1327             {
1328               /* We do nothing special here, because C++ does such nasty
1329                  things with TYPE_DECLs.  Instead, just let the TYPE_DECL
1330                  get shadowed, and know that if we need to find a TYPE_DECL
1331                  for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1332                  slot of the identifier.  */
1333               return NULL_TREE;
1334             }
1335             
1336             if ((TREE_CODE (newdecl) == FUNCTION_DECL
1337                  && DECL_FUNCTION_TEMPLATE_P (olddecl))
1338                 || (TREE_CODE (olddecl) == FUNCTION_DECL
1339                     && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1340               return NULL_TREE;
1341         }
1342
1343       error ("%q#D redeclared as different kind of symbol", newdecl);
1344       if (TREE_CODE (olddecl) == TREE_LIST)
1345         olddecl = TREE_VALUE (olddecl);
1346       error ("previous declaration of %q+#D", olddecl);
1347
1348       return error_mark_node;
1349     }
1350   else if (!types_match)
1351     {
1352       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1353         /* These are certainly not duplicate declarations; they're
1354            from different scopes.  */
1355         return NULL_TREE;
1356
1357       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1358         {
1359           /* The name of a class template may not be declared to refer to
1360              any other template, class, function, object, namespace, value,
1361              or type in the same scope.  */
1362           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1363               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1364             {
1365               error ("declaration of template %q#D", newdecl);
1366               error ("conflicts with previous declaration %q+#D", olddecl);
1367             }
1368           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1369                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1370                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1371                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1372                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1373                                            DECL_TEMPLATE_PARMS (olddecl))
1374                    /* Template functions can be disambiguated by
1375                       return type.  */
1376                    && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1377                                    TREE_TYPE (TREE_TYPE (olddecl))))
1378             {
1379               error ("new declaration %q#D", newdecl);
1380               error ("ambiguates old declaration %q+#D", olddecl);
1381             }
1382           return NULL_TREE;
1383         }
1384       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1385         {
1386           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1387             {
1388               error ("declaration of C function %q#D conflicts with",
1389                      newdecl);
1390               error ("previous declaration %q+#D here", olddecl);
1391             }
1392           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1393                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1394             {
1395               error ("new declaration %q#D", newdecl);
1396               error ("ambiguates old declaration %q+#D", olddecl);
1397               return error_mark_node;
1398             }
1399           else
1400             return NULL_TREE;
1401         }
1402       else
1403         {
1404           error ("conflicting declaration %q#D", newdecl);
1405           error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1406           return error_mark_node;
1407         }
1408     }
1409   else if (TREE_CODE (newdecl) == FUNCTION_DECL
1410             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1411                  && (!DECL_TEMPLATE_INFO (newdecl)
1412                      || (DECL_TI_TEMPLATE (newdecl)
1413                          != DECL_TI_TEMPLATE (olddecl))))
1414                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1415                     && (!DECL_TEMPLATE_INFO (olddecl)
1416                         || (DECL_TI_TEMPLATE (olddecl)
1417                             != DECL_TI_TEMPLATE (newdecl))))))
1418     /* It's OK to have a template specialization and a non-template
1419        with the same type, or to have specializations of two
1420        different templates with the same type.  Note that if one is a
1421        specialization, and the other is an instantiation of the same
1422        template, that we do not exit at this point.  That situation
1423        can occur if we instantiate a template class, and then
1424        specialize one of its methods.  This situation is valid, but
1425        the declarations must be merged in the usual way.  */
1426     return NULL_TREE;
1427   else if (TREE_CODE (newdecl) == FUNCTION_DECL
1428            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1429                 && !DECL_USE_TEMPLATE (newdecl))
1430                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1431                    && !DECL_USE_TEMPLATE (olddecl))))
1432     /* One of the declarations is a template instantiation, and the
1433        other is not a template at all.  That's OK.  */
1434     return NULL_TREE;
1435   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1436     {
1437       /* In [namespace.alias] we have:
1438
1439            In a declarative region, a namespace-alias-definition can be
1440            used to redefine a namespace-alias declared in that declarative
1441            region to refer only to the namespace to which it already
1442            refers.
1443
1444          Therefore, if we encounter a second alias directive for the same
1445          alias, we can just ignore the second directive.  */
1446       if (DECL_NAMESPACE_ALIAS (newdecl)
1447           && (DECL_NAMESPACE_ALIAS (newdecl)
1448               == DECL_NAMESPACE_ALIAS (olddecl)))
1449         return olddecl;
1450       /* [namespace.alias]
1451
1452          A namespace-name or namespace-alias shall not be declared as
1453          the name of any other entity in the same declarative region.
1454          A namespace-name defined at global scope shall not be
1455          declared as the name of any other entity in any global scope
1456          of the program.  */
1457       error ("declaration of namespace %qD conflicts with", newdecl);
1458       error ("previous declaration of namespace %q+D here", olddecl);
1459       return error_mark_node;
1460     }
1461   else
1462     {
1463       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1464       if (errmsg)
1465         {
1466           error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1467           if (DECL_NAME (olddecl) != NULL_TREE)
1468             error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1469                          ? "%q+#D previously defined here"
1470                          : "%q+#D previously declared here", olddecl);
1471           return error_mark_node;
1472         }
1473       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1474                && DECL_INITIAL (olddecl) != NULL_TREE
1475                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1476                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1477         {
1478           /* Prototype decl follows defn w/o prototype.  */
1479           warning_at (input_location, 0, "prototype for %q+#D", newdecl);
1480           warning_at (DECL_SOURCE_LOCATION (olddecl), 0,
1481                       "follows non-prototype definition here");
1482         }
1483       else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1484                 || TREE_CODE (olddecl) == VAR_DECL)
1485                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1486         {
1487           /* [dcl.link]
1488              If two declarations of the same function or object
1489              specify different linkage-specifications ..., the program
1490              is ill-formed.... Except for functions with C++ linkage,
1491              a function declaration without a linkage specification
1492              shall not precede the first linkage specification for
1493              that function.  A function can be declared without a
1494              linkage specification after an explicit linkage
1495              specification has been seen; the linkage explicitly
1496              specified in the earlier declaration is not affected by
1497              such a function declaration.
1498
1499              DR 563 raises the question why the restrictions on
1500              functions should not also apply to objects.  Older
1501              versions of G++ silently ignore the linkage-specification
1502              for this example:
1503
1504                namespace N { 
1505                  extern int i;
1506                  extern "C" int i;
1507                }
1508
1509              which is clearly wrong.  Therefore, we now treat objects
1510              like functions.  */
1511           if (current_lang_depth () == 0)
1512             {
1513               /* There is no explicit linkage-specification, so we use
1514                  the linkage from the previous declaration.  */
1515               if (!DECL_LANG_SPECIFIC (newdecl))
1516                 retrofit_lang_decl (newdecl);
1517               SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1518             }
1519           else
1520             {
1521               error ("previous declaration of %q+#D with %qL linkage",
1522                      olddecl, DECL_LANGUAGE (olddecl));
1523               error ("conflicts with new declaration with %qL linkage",
1524                      DECL_LANGUAGE (newdecl));
1525             }
1526         }
1527
1528       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1529         ;
1530       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1531         {
1532           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1533           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1534           int i = 1;
1535
1536           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1537             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1538
1539           for (; t1 && t1 != void_list_node;
1540                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1541             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1542               {
1543                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1544                                            TREE_PURPOSE (t2)))
1545                   {
1546                     permerror (input_location, "default argument given for parameter %d of %q#D",
1547                                i, newdecl);
1548                     permerror (input_location, "after previous specification in %q+#D", olddecl);
1549                   }
1550                 else
1551                   {
1552                     error ("default argument given for parameter %d of %q#D",
1553                            i, newdecl);
1554                     error ("after previous specification in %q+#D",
1555                                  olddecl);
1556                   }
1557               }
1558         }
1559     }
1560
1561   /* Do not merge an implicit typedef with an explicit one.  In:
1562
1563        class A;
1564        ...
1565        typedef class A A __attribute__ ((foo));
1566
1567      the attribute should apply only to the typedef.  */
1568   if (TREE_CODE (olddecl) == TYPE_DECL
1569       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1570           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1571     return NULL_TREE;
1572
1573   /* If new decl is `static' and an `extern' was seen previously,
1574      warn about it.  */
1575   warn_extern_redeclared_static (newdecl, olddecl);
1576
1577   /* We have committed to returning 1 at this point.  */
1578   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1579     {
1580       /* Now that functions must hold information normally held
1581          by field decls, there is extra work to do so that
1582          declaration information does not get destroyed during
1583          definition.  */
1584       if (DECL_VINDEX (olddecl))
1585         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1586       if (DECL_CONTEXT (olddecl))
1587         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1588       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1589       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1590       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1591       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1592       DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1593       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1594       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1595         SET_OVERLOADED_OPERATOR_CODE
1596           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1597       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1598
1599       /* Optionally warn about more than one declaration for the same
1600          name, but don't warn about a function declaration followed by a
1601          definition.  */
1602       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1603           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1604           /* Don't warn about extern decl followed by definition.  */
1605           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1606           /* Don't warn about friends, let add_friend take care of it.  */
1607           && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1608         {
1609           warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1610           warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1611         }
1612
1613       if (DECL_DELETED_FN (newdecl))
1614         {
1615           error ("deleted definition of %qD", newdecl);
1616           error ("after previous declaration %q+D", olddecl);
1617         }
1618     }
1619
1620   /* Deal with C++: must preserve virtual function table size.  */
1621   if (TREE_CODE (olddecl) == TYPE_DECL)
1622     {
1623       tree newtype = TREE_TYPE (newdecl);
1624       tree oldtype = TREE_TYPE (olddecl);
1625
1626       if (newtype != error_mark_node && oldtype != error_mark_node
1627           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1628         CLASSTYPE_FRIEND_CLASSES (newtype)
1629           = CLASSTYPE_FRIEND_CLASSES (oldtype);
1630
1631       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1632     }
1633
1634   /* Copy all the DECL_... slots specified in the new decl
1635      except for any that we copy here from the old type.  */
1636   DECL_ATTRIBUTES (newdecl)
1637     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1638
1639   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1640     {
1641       tree old_result;
1642       tree new_result;
1643       old_result = DECL_TEMPLATE_RESULT (olddecl);
1644       new_result = DECL_TEMPLATE_RESULT (newdecl);
1645       TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1646       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1647         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1648                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1649
1650       DECL_ATTRIBUTES (old_result)
1651         = (*targetm.merge_decl_attributes) (old_result, new_result);
1652
1653       if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1654         {
1655           if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1656               && DECL_INITIAL (new_result))
1657             {
1658               if (DECL_INITIAL (old_result))
1659                 DECL_UNINLINABLE (old_result) = 1;
1660               else
1661                 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1662               DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1663               DECL_NOT_REALLY_EXTERN (old_result)
1664                 = DECL_NOT_REALLY_EXTERN (new_result);
1665               DECL_INTERFACE_KNOWN (old_result)
1666                 = DECL_INTERFACE_KNOWN (new_result);
1667               DECL_DECLARED_INLINE_P (old_result)
1668                 = DECL_DECLARED_INLINE_P (new_result);
1669               DECL_DISREGARD_INLINE_LIMITS (old_result)
1670                 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1671
1672             }
1673           else
1674             {
1675               DECL_DECLARED_INLINE_P (old_result)
1676                 |= DECL_DECLARED_INLINE_P (new_result);
1677               DECL_DISREGARD_INLINE_LIMITS (old_result)
1678                 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1679               check_redeclaration_exception_specification (newdecl, olddecl);
1680             }
1681         }
1682
1683       /* If the new declaration is a definition, update the file and
1684          line information on the declaration, and also make
1685          the old declaration the same definition.  */
1686       if (DECL_INITIAL (new_result) != NULL_TREE)
1687         {
1688           DECL_SOURCE_LOCATION (olddecl)
1689             = DECL_SOURCE_LOCATION (old_result)
1690             = DECL_SOURCE_LOCATION (newdecl);
1691           DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1692           if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1693             {
1694               tree parm;
1695               DECL_ARGUMENTS (old_result)
1696                 = DECL_ARGUMENTS (new_result);
1697               for (parm = DECL_ARGUMENTS (old_result); parm;
1698                    parm = TREE_CHAIN (parm))
1699                 DECL_CONTEXT (parm) = old_result;
1700             }
1701         }
1702
1703       return olddecl;
1704     }
1705
1706   if (types_match)
1707     {
1708       /* Automatically handles default parameters.  */
1709       tree oldtype = TREE_TYPE (olddecl);
1710       tree newtype;
1711
1712       /* Merge the data types specified in the two decls.  */
1713       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1714
1715       /* If merge_types produces a non-typedef type, just use the old type.  */
1716       if (TREE_CODE (newdecl) == TYPE_DECL
1717           && newtype == DECL_ORIGINAL_TYPE (newdecl))
1718         newtype = oldtype;
1719
1720       if (TREE_CODE (newdecl) == VAR_DECL)
1721         {
1722           DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1723           DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1724           DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1725             |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1726           DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1727             |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1728
1729           /* Merge the threadprivate attribute from OLDDECL into NEWDECL.  */
1730           if (DECL_LANG_SPECIFIC (olddecl)
1731               && CP_DECL_THREADPRIVATE_P (olddecl))
1732             {
1733               /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed.  */
1734               if (!DECL_LANG_SPECIFIC (newdecl))
1735                 retrofit_lang_decl (newdecl);
1736
1737               DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1738               CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1739             }
1740         }
1741
1742       /* Do this after calling `merge_types' so that default
1743          parameters don't confuse us.  */
1744       else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1745         check_redeclaration_exception_specification (newdecl, olddecl);
1746       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1747
1748       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1749         check_default_args (newdecl);
1750
1751       /* Lay the type out, unless already done.  */
1752       if (! same_type_p (newtype, oldtype)
1753           && TREE_TYPE (newdecl) != error_mark_node
1754           && !(processing_template_decl && uses_template_parms (newdecl)))
1755         layout_type (TREE_TYPE (newdecl));
1756
1757       if ((TREE_CODE (newdecl) == VAR_DECL
1758            || TREE_CODE (newdecl) == PARM_DECL
1759            || TREE_CODE (newdecl) == RESULT_DECL
1760            || TREE_CODE (newdecl) == FIELD_DECL
1761            || TREE_CODE (newdecl) == TYPE_DECL)
1762           && !(processing_template_decl && uses_template_parms (newdecl)))
1763         layout_decl (newdecl, 0);
1764
1765       /* Merge the type qualifiers.  */
1766       if (TREE_READONLY (newdecl))
1767         TREE_READONLY (olddecl) = 1;
1768       if (TREE_THIS_VOLATILE (newdecl))
1769         TREE_THIS_VOLATILE (olddecl) = 1;
1770       if (TREE_NOTHROW (newdecl))
1771         TREE_NOTHROW (olddecl) = 1;
1772
1773       /* Merge deprecatedness.  */
1774       if (TREE_DEPRECATED (newdecl))
1775         TREE_DEPRECATED (olddecl) = 1;
1776
1777       /* Preserve function specific target and optimization options */
1778       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1779         {
1780           if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
1781               && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
1782             DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
1783               = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
1784
1785           if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
1786               && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
1787             DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
1788               = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
1789         }
1790
1791       /* Merge the initialization information.  */
1792       if (DECL_INITIAL (newdecl) == NULL_TREE
1793           && DECL_INITIAL (olddecl) != NULL_TREE)
1794         {
1795           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1796           DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1797           if (TREE_CODE (newdecl) == FUNCTION_DECL)
1798             {
1799               DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1800               DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1801             }
1802         }
1803
1804       /* Merge the section attribute.
1805          We want to issue an error if the sections conflict but that must be
1806          done later in decl_attributes since we are called before attributes
1807          are assigned.  */
1808       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1809         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1810
1811       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1812         {
1813           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1814             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1815           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1816           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1817           TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1818           DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1819           DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
1820           DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1821           TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1822           DECL_LOOPING_CONST_OR_PURE_P (newdecl) 
1823             |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
1824           /* Keep the old RTL.  */
1825           COPY_DECL_RTL (olddecl, newdecl);
1826         }
1827       else if (TREE_CODE (newdecl) == VAR_DECL
1828                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1829         {
1830           /* Keep the old RTL.  We cannot keep the old RTL if the old
1831              declaration was for an incomplete object and the new
1832              declaration is not since many attributes of the RTL will
1833              change.  */
1834           COPY_DECL_RTL (olddecl, newdecl);
1835         }
1836     }
1837   /* If cannot merge, then use the new type and qualifiers,
1838      and don't preserve the old rtl.  */
1839   else
1840     {
1841       /* Clean out any memory we had of the old declaration.  */
1842       tree oldstatic = value_member (olddecl, static_aggregates);
1843       if (oldstatic)
1844         TREE_VALUE (oldstatic) = error_mark_node;
1845
1846       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1847       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1848       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1849       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1850     }
1851
1852   /* Merge the storage class information.  */
1853   merge_weak (newdecl, olddecl);
1854
1855   if (DECL_ONE_ONLY (olddecl))
1856     DECL_COMDAT_GROUP (newdecl) = DECL_COMDAT_GROUP (olddecl);
1857
1858   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1859   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1860   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1861   if (! DECL_EXTERNAL (olddecl))
1862     DECL_EXTERNAL (newdecl) = 0;
1863
1864   new_template_info = NULL_TREE;
1865   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1866     {
1867       bool new_redefines_gnu_inline = false;
1868
1869       if (new_defines_function
1870           && ((DECL_INTERFACE_KNOWN (olddecl)
1871                && TREE_CODE (olddecl) == FUNCTION_DECL)
1872               || (TREE_CODE (olddecl) == TEMPLATE_DECL
1873                   && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1874                       == FUNCTION_DECL))))
1875         {
1876           tree fn = olddecl;
1877
1878           if (TREE_CODE (fn) == TEMPLATE_DECL)
1879             fn = DECL_TEMPLATE_RESULT (olddecl);
1880
1881           new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
1882         }
1883
1884       if (!new_redefines_gnu_inline)
1885         {
1886           DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1887           DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1888           DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1889         }
1890       DECL_TEMPLATE_INSTANTIATED (newdecl)
1891         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1892       DECL_ODR_USED (newdecl) |= DECL_ODR_USED (olddecl);
1893
1894       /* If the OLDDECL is an instantiation and/or specialization,
1895          then the NEWDECL must be too.  But, it may not yet be marked
1896          as such if the caller has created NEWDECL, but has not yet
1897          figured out that it is a redeclaration.  */
1898       if (!DECL_USE_TEMPLATE (newdecl))
1899         DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1900
1901       /* Don't really know how much of the language-specific
1902          values we should copy from old to new.  */
1903       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1904       DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1905       DECL_INITIALIZED_IN_CLASS_P (newdecl)
1906         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1907
1908       if (LANG_DECL_HAS_MIN (newdecl))
1909         {
1910           DECL_LANG_SPECIFIC (newdecl)->u.min.u2 =
1911             DECL_LANG_SPECIFIC (olddecl)->u.min.u2;
1912           if (DECL_TEMPLATE_INFO (newdecl))
1913             new_template_info = DECL_TEMPLATE_INFO (newdecl);
1914           DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1915         }
1916       /* Only functions have these fields.  */
1917       if (TREE_CODE (newdecl) == FUNCTION_DECL
1918           || DECL_FUNCTION_TEMPLATE_P (newdecl))
1919         {
1920           DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1921           olddecl_friend = DECL_FRIEND_P (olddecl);
1922           hidden_friend = (DECL_ANTICIPATED (olddecl)
1923                            && DECL_HIDDEN_FRIEND_P (olddecl)
1924                            && newdecl_is_friend);
1925           DECL_BEFRIENDING_CLASSES (newdecl)
1926             = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1927                        DECL_BEFRIENDING_CLASSES (olddecl));
1928           /* DECL_THUNKS is only valid for virtual functions,
1929              otherwise it is a DECL_FRIEND_CONTEXT.  */
1930           if (DECL_VIRTUAL_P (newdecl))
1931             DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1932         }
1933     }
1934
1935   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1936     {
1937       tree parm;
1938
1939       /* Merge parameter attributes. */
1940       tree oldarg, newarg;
1941       for (oldarg = DECL_ARGUMENTS(olddecl), 
1942                newarg = DECL_ARGUMENTS(newdecl);
1943            oldarg && newarg;
1944            oldarg = TREE_CHAIN(oldarg), newarg = TREE_CHAIN(newarg)) {
1945           DECL_ATTRIBUTES (newarg)
1946               = (*targetm.merge_decl_attributes) (oldarg, newarg);
1947           DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
1948       }
1949       
1950       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1951           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1952         {
1953           /* If newdecl is not a specialization, then it is not a
1954              template-related function at all.  And that means that we
1955              should have exited above, returning 0.  */
1956           gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1957
1958           if (DECL_ODR_USED (olddecl))
1959             /* From [temp.expl.spec]:
1960
1961                If a template, a member template or the member of a class
1962                template is explicitly specialized then that
1963                specialization shall be declared before the first use of
1964                that specialization that would cause an implicit
1965                instantiation to take place, in every translation unit in
1966                which such a use occurs.  */
1967             error ("explicit specialization of %qD after first use",
1968                       olddecl);
1969
1970           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1971
1972           /* Don't propagate visibility from the template to the
1973              specialization here.  We'll do that in determine_visibility if
1974              appropriate.  */
1975           DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
1976
1977           /* [temp.expl.spec/14] We don't inline explicit specialization
1978              just because the primary template says so.  */
1979         }
1980       else if (new_defines_function && DECL_INITIAL (olddecl))
1981         {
1982           /* Never inline re-defined extern inline functions.
1983              FIXME: this could be better handled by keeping both
1984              function as separate declarations.  */
1985           DECL_UNINLINABLE (newdecl) = 1;
1986         }
1987       else
1988         {
1989           if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1990             DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1991
1992           DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1993
1994           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1995             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1996
1997           DECL_DISREGARD_INLINE_LIMITS (newdecl)
1998             = DECL_DISREGARD_INLINE_LIMITS (olddecl)
1999             = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2000                || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2001         }
2002
2003       /* Preserve abstractness on cloned [cd]tors.  */
2004       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
2005
2006       /* Update newdecl's parms to point at olddecl.  */
2007       for (parm = DECL_ARGUMENTS (newdecl); parm;
2008            parm = TREE_CHAIN (parm))
2009         DECL_CONTEXT (parm) = olddecl;
2010
2011       if (! types_match)
2012         {
2013           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
2014           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
2015           COPY_DECL_RTL (newdecl, olddecl);
2016         }
2017       if (! types_match || new_defines_function)
2018         {
2019           /* These need to be copied so that the names are available.
2020              Note that if the types do match, we'll preserve inline
2021              info and other bits, but if not, we won't.  */
2022           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2023           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2024         }
2025       if (new_defines_function)
2026         /* If defining a function declared with other language
2027            linkage, use the previously declared language linkage.  */
2028         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2029       else if (types_match)
2030         {
2031           /* If redeclaring a builtin function, and not a definition,
2032              it stays built in.  */
2033           if (DECL_BUILT_IN (olddecl))
2034             {
2035               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2036               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2037               /* If we're keeping the built-in definition, keep the rtl,
2038                  regardless of declaration matches.  */
2039               COPY_DECL_RTL (olddecl, newdecl);
2040             }
2041
2042           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2043           /* Don't clear out the arguments if we're just redeclaring a
2044              function.  */
2045           if (DECL_ARGUMENTS (olddecl))
2046             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2047         }
2048     }
2049   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2050     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2051
2052   /* Now preserve various other info from the definition.  */
2053   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2054   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2055   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2056   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2057
2058   /* Warn about conflicting visibility specifications.  */
2059   if (DECL_VISIBILITY_SPECIFIED (olddecl)
2060       && DECL_VISIBILITY_SPECIFIED (newdecl)
2061       && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2062     {
2063       warning_at (input_location, OPT_Wattributes,
2064                   "%q+D: visibility attribute ignored because it", newdecl);
2065       warning_at (DECL_SOURCE_LOCATION (olddecl), OPT_Wattributes,
2066                   "conflicts with previous declaration here");
2067     }
2068   /* Choose the declaration which specified visibility.  */
2069   if (DECL_VISIBILITY_SPECIFIED (olddecl))
2070     {
2071       DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2072       DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2073     }
2074   /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2075      so keep this behavior.  */
2076   if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2077     {
2078       SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2079       DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2080     }
2081
2082   /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2083      with that from NEWDECL below.  */
2084   if (DECL_LANG_SPECIFIC (olddecl))
2085     {
2086       gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2087                   != DECL_LANG_SPECIFIC (newdecl));
2088       ggc_free (DECL_LANG_SPECIFIC (olddecl));
2089     }
2090
2091   /* Merge the USED information.  */
2092   if (TREE_USED (olddecl))
2093     TREE_USED (newdecl) = 1;
2094   else if (TREE_USED (newdecl))
2095     TREE_USED (olddecl) = 1;
2096
2097   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2098     {
2099       int function_size;
2100
2101       function_size = sizeof (struct tree_decl_common);
2102
2103       memcpy ((char *) olddecl + sizeof (struct tree_common),
2104               (char *) newdecl + sizeof (struct tree_common),
2105               function_size - sizeof (struct tree_common));
2106
2107       memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2108               (char *) newdecl + sizeof (struct tree_decl_common),
2109               sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2110       if (new_template_info)
2111         /* If newdecl is a template instantiation, it is possible that
2112            the following sequence of events has occurred:
2113
2114            o A friend function was declared in a class template.  The
2115            class template was instantiated.
2116
2117            o The instantiation of the friend declaration was
2118            recorded on the instantiation list, and is newdecl.
2119
2120            o Later, however, instantiate_class_template called pushdecl
2121            on the newdecl to perform name injection.  But, pushdecl in
2122            turn called duplicate_decls when it discovered that another
2123            declaration of a global function with the same name already
2124            existed.
2125
2126            o Here, in duplicate_decls, we decided to clobber newdecl.
2127
2128            If we're going to do that, we'd better make sure that
2129            olddecl, and not newdecl, is on the list of
2130            instantiations so that if we try to do the instantiation
2131            again we won't get the clobbered declaration.  */
2132         reregister_specialization (newdecl,
2133                                    new_template_info,
2134                                    olddecl);
2135     }
2136   else
2137     {
2138       size_t size = tree_code_size (TREE_CODE (olddecl));
2139       memcpy ((char *) olddecl + sizeof (struct tree_common),
2140               (char *) newdecl + sizeof (struct tree_common),
2141               sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2142       switch (TREE_CODE (olddecl))
2143         {
2144         case LABEL_DECL:
2145         case VAR_DECL:
2146         case RESULT_DECL:
2147         case PARM_DECL:
2148         case FIELD_DECL:
2149         case TYPE_DECL:
2150         case CONST_DECL:
2151           {
2152             memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2153                     (char *) newdecl + sizeof (struct tree_decl_common),
2154                     size - sizeof (struct tree_decl_common)
2155                     + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2156           }
2157           break;
2158         default:
2159           memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2160                   (char *) newdecl + sizeof (struct tree_decl_common),
2161                   sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2162                   + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2163           break;
2164         }
2165     }
2166   DECL_UID (olddecl) = olddecl_uid;
2167   if (olddecl_friend)
2168     DECL_FRIEND_P (olddecl) = 1;
2169   if (hidden_friend)
2170     {
2171       DECL_ANTICIPATED (olddecl) = 1;
2172       DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2173     }
2174
2175   /* NEWDECL contains the merged attribute lists.
2176      Update OLDDECL to be the same.  */
2177   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2178
2179   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2180     so that encode_section_info has a chance to look at the new decl
2181     flags and attributes.  */
2182   if (DECL_RTL_SET_P (olddecl)
2183       && (TREE_CODE (olddecl) == FUNCTION_DECL
2184           || (TREE_CODE (olddecl) == VAR_DECL
2185               && TREE_STATIC (olddecl))))
2186     make_decl_rtl (olddecl);
2187
2188   /* The NEWDECL will no longer be needed.  Because every out-of-class
2189      declaration of a member results in a call to duplicate_decls,
2190      freeing these nodes represents in a significant savings.  */
2191   ggc_free (newdecl);
2192
2193   return olddecl;
2194 }
2195 \f
2196 /* Return zero if the declaration NEWDECL is valid
2197    when the declaration OLDDECL (assumed to be for the same name)
2198    has already been seen.
2199    Otherwise return an error message format string with a %s
2200    where the identifier should go.  */
2201
2202 static const char *
2203 redeclaration_error_message (tree newdecl, tree olddecl)
2204 {
2205   if (TREE_CODE (newdecl) == TYPE_DECL)
2206     {
2207       /* Because C++ can put things into name space for free,
2208          constructs like "typedef struct foo { ... } foo"
2209          would look like an erroneous redeclaration.  */
2210       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2211         return NULL;
2212       else
2213         return G_("redefinition of %q#D");
2214     }
2215   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2216     {
2217       /* If this is a pure function, its olddecl will actually be
2218          the original initialization to `0' (which we force to call
2219          abort()).  Don't complain about redefinition in this case.  */
2220       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2221           && DECL_INITIAL (olddecl) == NULL_TREE)
2222         return NULL;
2223
2224       /* If both functions come from different namespaces, this is not
2225          a redeclaration - this is a conflict with a used function.  */
2226       if (DECL_NAMESPACE_SCOPE_P (olddecl)
2227           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2228           && ! decls_match (olddecl, newdecl))
2229         return G_("%qD conflicts with used function");
2230
2231       /* We'll complain about linkage mismatches in
2232          warn_extern_redeclared_static.  */
2233
2234       /* Defining the same name twice is no good.  */
2235       if (DECL_INITIAL (olddecl) != NULL_TREE
2236           && DECL_INITIAL (newdecl) != NULL_TREE)
2237         {
2238           if (DECL_NAME (olddecl) == NULL_TREE)
2239             return G_("%q#D not declared in class");
2240           else if (!GNU_INLINE_P (olddecl)
2241                    || GNU_INLINE_P (newdecl))
2242             return G_("redefinition of %q#D");
2243         }
2244
2245       if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2246         {
2247           bool olda = GNU_INLINE_P (olddecl);
2248           bool newa = GNU_INLINE_P (newdecl);
2249
2250           if (olda != newa)
2251             {
2252               if (newa)
2253                 return G_("%q+D redeclared inline with "
2254                           "%<gnu_inline%> attribute");
2255               else
2256                 return G_("%q+D redeclared inline without "
2257                           "%<gnu_inline%> attribute");
2258             }
2259         }
2260
2261       return NULL;
2262     }
2263   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2264     {
2265       tree nt, ot;
2266
2267       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2268         {
2269           if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2270               && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2271             return G_("redefinition of %q#D");
2272           return NULL;
2273         }
2274
2275       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2276           || (DECL_TEMPLATE_RESULT (newdecl)
2277               == DECL_TEMPLATE_RESULT (olddecl)))
2278         return NULL;
2279
2280       nt = DECL_TEMPLATE_RESULT (newdecl);
2281       if (DECL_TEMPLATE_INFO (nt))
2282         nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2283       ot = DECL_TEMPLATE_RESULT (olddecl);
2284       if (DECL_TEMPLATE_INFO (ot))
2285         ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2286       if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2287           && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2288         return G_("redefinition of %q#D");
2289
2290       if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2291         {
2292           bool olda = GNU_INLINE_P (ot);
2293           bool newa = GNU_INLINE_P (nt);
2294
2295           if (olda != newa)
2296             {
2297               if (newa)
2298                 return G_("%q+D redeclared inline with "
2299                           "%<gnu_inline%> attribute");
2300               else
2301                 return G_("%q+D redeclared inline without "
2302                           "%<gnu_inline%> attribute");
2303             }
2304         }
2305
2306       /* Core issue #226 (C++0x): 
2307            
2308            If a friend function template declaration specifies a
2309            default template-argument, that declaration shall be a
2310            definition and shall be the only declaration of the
2311            function template in the translation unit.  */
2312       if ((cxx_dialect != cxx98) 
2313           && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2314           && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl), 
2315                                        /*is_primary=*/1, /*is_partial=*/0,
2316                                        /*is_friend_decl=*/2))
2317         return G_("redeclaration of friend %q#D "
2318                   "may not have default template arguments");
2319
2320       return NULL;
2321     }
2322   else if (TREE_CODE (newdecl) == VAR_DECL
2323            && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2324            && (! DECL_LANG_SPECIFIC (olddecl)
2325                || ! CP_DECL_THREADPRIVATE_P (olddecl)
2326                || DECL_THREAD_LOCAL_P (newdecl)))
2327     {
2328       /* Only variables can be thread-local, and all declarations must
2329          agree on this property.  */
2330       if (DECL_THREAD_LOCAL_P (newdecl))
2331         return G_("thread-local declaration of %q#D follows "
2332                   "non-thread-local declaration");
2333       else
2334         return G_("non-thread-local declaration of %q#D follows "
2335                   "thread-local declaration");
2336     }
2337   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2338     {
2339       /* The objects have been declared at namespace scope.  If either
2340          is a member of an anonymous union, then this is an invalid
2341          redeclaration.  For example:
2342
2343            int i;
2344            union { int i; };
2345
2346            is invalid.  */
2347       if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2348           || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2349         return G_("redeclaration of %q#D");
2350       /* If at least one declaration is a reference, there is no
2351          conflict.  For example:
2352
2353            int i = 3;
2354            extern int i;
2355
2356          is valid.  */
2357       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2358         return NULL;
2359       /* Reject two definitions.  */
2360       return G_("redefinition of %q#D");
2361     }
2362   else
2363     {
2364       /* Objects declared with block scope:  */
2365       /* Reject two definitions, and reject a definition
2366          together with an external reference.  */
2367       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2368         return G_("redeclaration of %q#D");
2369       return NULL;
2370     }
2371 }
2372 \f
2373 /* Hash and equality functions for the named_label table.  */
2374
2375 static hashval_t
2376 named_label_entry_hash (const void *data)
2377 {
2378   const struct named_label_entry *ent = (const struct named_label_entry *) data;
2379   return DECL_UID (ent->label_decl);
2380 }
2381
2382 static int
2383 named_label_entry_eq (const void *a, const void *b)
2384 {
2385   const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2386   const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2387   return ent_a->label_decl == ent_b->label_decl;
2388 }
2389
2390 /* Create a new label, named ID.  */
2391
2392 static tree
2393 make_label_decl (tree id, int local_p)
2394 {
2395   struct named_label_entry *ent;
2396   void **slot;
2397   tree decl;
2398
2399   decl = build_decl (input_location, LABEL_DECL, id, void_type_node);
2400
2401   DECL_CONTEXT (decl) = current_function_decl;
2402   DECL_MODE (decl) = VOIDmode;
2403   C_DECLARED_LABEL_FLAG (decl) = local_p;
2404
2405   /* Say where one reference is to the label, for the sake of the
2406      error if it is not defined.  */
2407   DECL_SOURCE_LOCATION (decl) = input_location;
2408
2409   /* Record the fact that this identifier is bound to this label.  */
2410   SET_IDENTIFIER_LABEL_VALUE (id, decl);
2411
2412   /* Create the label htab for the function on demand.  */
2413   if (!named_labels)
2414     named_labels = htab_create_ggc (13, named_label_entry_hash,
2415                                     named_label_entry_eq, NULL);
2416
2417   /* Record this label on the list of labels used in this function.
2418      We do this before calling make_label_decl so that we get the
2419      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
2420   ent = GGC_CNEW (struct named_label_entry);
2421   ent->label_decl = decl;
2422
2423   slot = htab_find_slot (named_labels, ent, INSERT);
2424   gcc_assert (*slot == NULL);
2425   *slot = ent;
2426
2427   return decl;
2428 }
2429
2430 /* Look for a label named ID in the current function.  If one cannot
2431    be found, create one.  (We keep track of used, but undefined,
2432    labels, and complain about them at the end of a function.)  */
2433
2434 tree
2435 lookup_label (tree id)
2436 {
2437   tree decl;
2438
2439   timevar_push (TV_NAME_LOOKUP);
2440   /* You can't use labels at global scope.  */
2441   if (current_function_decl == NULL_TREE)
2442     {
2443       error ("label %qE referenced outside of any function", id);
2444       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2445     }
2446
2447   /* See if we've already got this label.  */
2448   decl = IDENTIFIER_LABEL_VALUE (id);
2449   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2450     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2451
2452   decl = make_label_decl (id, /*local_p=*/0);
2453   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2454 }
2455
2456 /* Declare a local label named ID.  */
2457
2458 tree
2459 declare_local_label (tree id)
2460 {
2461   tree decl, shadow;
2462
2463   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2464      this scope we can restore the old value of IDENTIFIER_TYPE_VALUE.  */
2465   shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2466                       current_binding_level->shadowed_labels);
2467   current_binding_level->shadowed_labels = shadow;
2468
2469   decl = make_label_decl (id, /*local_p=*/1);
2470   TREE_VALUE (shadow) = decl;
2471
2472   return decl;
2473 }
2474
2475 /* Returns nonzero if it is ill-formed to jump past the declaration of
2476    DECL.  Returns 2 if it's also a real problem.  */
2477
2478 static int
2479 decl_jump_unsafe (tree decl)
2480 {
2481   /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2482      with automatic storage duration is not in scope to a point where it is
2483      in scope is ill-formed unless the variable has scalar type, class type
2484      with a trivial default constructor and a trivial destructor, a
2485      cv-qualified version of one of these types, or an array of one of the
2486      preceding types and is declared without an initializer (8.5).  */
2487   tree type = TREE_TYPE (decl);
2488
2489   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2490       || type == error_mark_node)
2491     return 0;
2492
2493   type = strip_array_types (type);
2494
2495   if (type_has_nontrivial_default_init (TREE_TYPE (decl))
2496       || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2497     return 2;
2498
2499   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2500     return 1;
2501
2502   return 0;
2503 }
2504
2505 /* A subroutine of check_previous_goto_1 to identify a branch to the user.  */
2506
2507 static void
2508 identify_goto (tree decl, const location_t *locus)
2509 {
2510   if (decl)
2511     permerror (input_location, "jump to label %qD", decl);
2512   else
2513     permerror (input_location, "jump to case label");
2514   if (locus)
2515     permerror (*locus, "  from here");
2516 }
2517
2518 /* Check that a single previously seen jump to a newly defined label
2519    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2520    the jump context; NAMES are the names in scope in LEVEL at the jump
2521    context; LOCUS is the source position of the jump or 0.  Returns
2522    true if all is well.  */
2523
2524 static bool
2525 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2526                        bool exited_omp, const location_t *locus)
2527 {
2528   struct cp_binding_level *b;
2529   bool identified = false, saw_eh = false, saw_omp = false;
2530
2531   if (exited_omp)
2532     {
2533       identify_goto (decl, locus);
2534       error ("  exits OpenMP structured block");
2535       identified = saw_omp = true;
2536     }
2537
2538   for (b = current_binding_level; b ; b = b->level_chain)
2539     {
2540       tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2541
2542       for (new_decls = b->names; new_decls != old_decls;
2543            new_decls = TREE_CHAIN (new_decls))
2544         {
2545           int problem = decl_jump_unsafe (new_decls);
2546           if (! problem)
2547             continue;
2548
2549           if (!identified)
2550             {
2551               identify_goto (decl, locus);
2552               identified = true;
2553             }
2554           if (problem > 1)
2555             error ("  crosses initialization of %q+#D", new_decls);
2556           else
2557             permerror (input_location, "  enters scope of %q+#D which has "
2558                        "non-trivial destructor", new_decls);
2559         }
2560
2561       if (b == level)
2562         break;
2563       if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2564         {
2565           if (!identified)
2566             {
2567               identify_goto (decl, locus);
2568               identified = true;
2569             }
2570           if (b->kind == sk_try)
2571             error ("  enters try block");
2572           else
2573             error ("  enters catch block");
2574           saw_eh = true;
2575         }
2576       if (b->kind == sk_omp && !saw_omp)
2577         {
2578           if (!identified)
2579             {
2580               identify_goto (decl, locus);
2581               identified = true;
2582             }
2583           error ("  enters OpenMP structured block");
2584           saw_omp = true;
2585         }
2586     }
2587
2588   return !identified;
2589 }
2590
2591 static void
2592 check_previous_goto (tree decl, struct named_label_use_entry *use)
2593 {
2594   check_previous_goto_1 (decl, use->binding_level,
2595                          use->names_in_scope, use->in_omp_scope,
2596                          &use->o_goto_locus);
2597 }
2598
2599 static bool
2600 check_switch_goto (struct cp_binding_level* level)
2601 {
2602   return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2603 }
2604
2605 /* Check that a new jump to a label DECL is OK.  Called by
2606    finish_goto_stmt.  */
2607
2608 void
2609 check_goto (tree decl)
2610 {
2611   struct named_label_entry *ent, dummy;
2612   bool saw_catch = false, identified = false;
2613   tree bad;
2614
2615   /* We can't know where a computed goto is jumping.
2616      So we assume that it's OK.  */
2617   if (TREE_CODE (decl) != LABEL_DECL)
2618     return;
2619
2620   /* We didn't record any information about this label when we created it,
2621      and there's not much point since it's trivial to analyze as a return.  */
2622   if (decl == cdtor_label)
2623     return;
2624
2625   dummy.label_decl = decl;
2626   ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2627   gcc_assert (ent != NULL);
2628
2629   /* If the label hasn't been defined yet, defer checking.  */
2630   if (! DECL_INITIAL (decl))
2631     {
2632       struct named_label_use_entry *new_use;
2633
2634       /* Don't bother creating another use if the last goto had the
2635          same data, and will therefore create the same set of errors.  */
2636       if (ent->uses
2637           && ent->uses->names_in_scope == current_binding_level->names)
2638         return;
2639
2640       new_use = GGC_NEW (struct named_label_use_entry);
2641       new_use->binding_level = current_binding_level;
2642       new_use->names_in_scope = current_binding_level->names;
2643       new_use->o_goto_locus = input_location;
2644       new_use->in_omp_scope = false;
2645
2646       new_use->next = ent->uses;
2647       ent->uses = new_use;
2648       return;
2649     }
2650
2651   if (ent->in_try_scope || ent->in_catch_scope
2652       || ent->in_omp_scope || ent->bad_decls)
2653     {
2654       permerror (input_location, "jump to label %q+D", decl);
2655       permerror (input_location, "  from here");
2656       identified = true;
2657     }
2658
2659   for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2660     {
2661       tree b = TREE_VALUE (bad);
2662       int u = decl_jump_unsafe (b);
2663
2664       if (u > 1 && DECL_ARTIFICIAL (b))
2665         {
2666           /* Can't skip init of __exception_info.  */
2667           error_at (DECL_SOURCE_LOCATION (b), "  enters catch block");
2668           saw_catch = true;
2669         }
2670       else if (u > 1)
2671         error ("  skips initialization of %q+#D", b);
2672       else
2673         permerror (input_location, "  enters scope of %q+#D which has "
2674                    "non-trivial destructor", b);
2675     }
2676
2677   if (ent->in_try_scope)
2678     error ("  enters try block");
2679   else if (ent->in_catch_scope && !saw_catch)
2680     error ("  enters catch block");
2681
2682   if (ent->in_omp_scope)
2683     error ("  enters OpenMP structured block");
2684   else if (flag_openmp)
2685     {
2686       struct cp_binding_level *b;
2687       for (b = current_binding_level; b ; b = b->level_chain)
2688         {
2689           if (b == ent->binding_level)
2690             break;
2691           if (b->kind == sk_omp)
2692             {
2693               if (!identified)
2694                 {
2695                   permerror (input_location, "jump to label %q+D", decl);
2696                   permerror (input_location, "  from here");
2697                   identified = true;
2698                 }
2699               error ("  exits OpenMP structured block");
2700               break;
2701             }
2702         }
2703     }
2704 }
2705
2706 /* Check that a return is ok wrt OpenMP structured blocks.
2707    Called by finish_return_stmt.  Returns true if all is well.  */
2708
2709 bool
2710 check_omp_return (void)
2711 {
2712   struct cp_binding_level *b;
2713   for (b = current_binding_level; b ; b = b->level_chain)
2714     if (b->kind == sk_omp)
2715       {
2716         error ("invalid exit from OpenMP structured block");
2717         return false;
2718       }
2719   return true;
2720 }
2721
2722 /* Define a label, specifying the location in the source file.
2723    Return the LABEL_DECL node for the label.  */
2724
2725 tree
2726 define_label (location_t location, tree name)
2727 {
2728   struct named_label_entry *ent, dummy;
2729   struct cp_binding_level *p;
2730   tree decl;
2731
2732   timevar_push (TV_NAME_LOOKUP);
2733
2734   decl = lookup_label (name);
2735
2736   dummy.label_decl = decl;
2737   ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2738   gcc_assert (ent != NULL);
2739
2740   /* After labels, make any new cleanups in the function go into their
2741      own new (temporary) binding contour.  */
2742   for (p = current_binding_level;
2743        p->kind != sk_function_parms;
2744        p = p->level_chain)
2745     p->more_cleanups_ok = 0;
2746
2747   if (name == get_identifier ("wchar_t"))
2748     permerror (input_location, "label named wchar_t");
2749
2750   if (DECL_INITIAL (decl) != NULL_TREE)
2751     {
2752       error ("duplicate label %qD", decl);
2753       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2754     }
2755   else
2756     {
2757       struct named_label_use_entry *use;
2758
2759       /* Mark label as having been defined.  */
2760       DECL_INITIAL (decl) = error_mark_node;
2761       /* Say where in the source.  */
2762       DECL_SOURCE_LOCATION (decl) = location;
2763
2764       ent->binding_level = current_binding_level;
2765       ent->names_in_scope = current_binding_level->names;
2766
2767       for (use = ent->uses; use ; use = use->next)
2768         check_previous_goto (decl, use);
2769       ent->uses = NULL;
2770     }
2771
2772   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2773 }
2774
2775 struct cp_switch
2776 {
2777   struct cp_binding_level *level;
2778   struct cp_switch *next;
2779   /* The SWITCH_STMT being built.  */
2780   tree switch_stmt;
2781   /* A splay-tree mapping the low element of a case range to the high
2782      element, or NULL_TREE if there is no high element.  Used to
2783      determine whether or not a new case label duplicates an old case
2784      label.  We need a tree, rather than simply a hash table, because
2785      of the GNU case range extension.  */
2786   splay_tree cases;
2787 };
2788
2789 /* A stack of the currently active switch statements.  The innermost
2790    switch statement is on the top of the stack.  There is no need to
2791    mark the stack for garbage collection because it is only active
2792    during the processing of the body of a function, and we never
2793    collect at that point.  */
2794
2795 static struct cp_switch *switch_stack;
2796
2797 /* Called right after a switch-statement condition is parsed.
2798    SWITCH_STMT is the switch statement being parsed.  */
2799
2800 void
2801 push_switch (tree switch_stmt)
2802 {
2803   struct cp_switch *p = XNEW (struct cp_switch);
2804   p->level = current_binding_level;
2805   p->next = switch_stack;
2806   p->switch_stmt = switch_stmt;
2807   p->cases = splay_tree_new (case_compare, NULL, NULL);
2808   switch_stack = p;
2809 }
2810
2811 void
2812 pop_switch (void)
2813 {
2814   struct cp_switch *cs = switch_stack;
2815   location_t switch_location;
2816
2817   /* Emit warnings as needed.  */
2818   if (EXPR_HAS_LOCATION (cs->switch_stmt))
2819     switch_location = EXPR_LOCATION (cs->switch_stmt);
2820   else
2821     switch_location = input_location;
2822   if (!processing_template_decl)
2823     c_do_switch_warnings (cs->cases, switch_location,
2824                           SWITCH_STMT_TYPE (cs->switch_stmt),
2825                           SWITCH_STMT_COND (cs->switch_stmt));
2826
2827   splay_tree_delete (cs->cases);
2828   switch_stack = switch_stack->next;
2829   free (cs);
2830 }
2831
2832 /* Note that we've seen a definition of a case label, and complain if this
2833    is a bad place for one.  */
2834
2835 tree
2836 finish_case_label (location_t loc, tree low_value, tree high_value)
2837 {
2838   tree cond, r;
2839   struct cp_binding_level *p;
2840
2841   if (processing_template_decl)
2842     {
2843       tree label;
2844
2845       /* For templates, just add the case label; we'll do semantic
2846          analysis at instantiation-time.  */
2847       label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE);
2848       return add_stmt (build_case_label (loc, low_value, high_value, label));
2849     }
2850
2851   /* Find the condition on which this switch statement depends.  */
2852   cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2853   if (cond && TREE_CODE (cond) == TREE_LIST)
2854     cond = TREE_VALUE (cond);
2855
2856   if (!check_switch_goto (switch_stack->level))
2857     return error_mark_node;
2858
2859   r = c_add_case_label (loc, switch_stack->cases, cond,
2860                         SWITCH_STMT_TYPE (switch_stack->switch_stmt),
2861                         low_value, high_value);
2862
2863   /* After labels, make any new cleanups in the function go into their
2864      own new (temporary) binding contour.  */
2865   for (p = current_binding_level;
2866        p->kind != sk_function_parms;
2867        p = p->level_chain)
2868     p->more_cleanups_ok = 0;
2869
2870   return r;
2871 }
2872 \f
2873 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
2874
2875 static hashval_t
2876 typename_hash (const void* k)
2877 {
2878   hashval_t hash;
2879   const_tree const t = (const_tree) k;
2880
2881   hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2882           ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2883
2884   return hash;
2885 }
2886
2887 typedef struct typename_info {
2888   tree scope;
2889   tree name;
2890   tree template_id;
2891   bool enum_p;
2892   bool class_p;
2893 } typename_info;
2894
2895 /* Compare two TYPENAME_TYPEs.  K1 is really of type `tree', K2 is
2896    really of type `typename_info*'  */
2897
2898 static int
2899 typename_compare (const void * k1, const void * k2)
2900 {
2901   const_tree const t1 = (const_tree) k1;
2902   const typename_info *const t2 = (const typename_info *) k2;
2903
2904   return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2905           && TYPE_CONTEXT (t1) == t2->scope
2906           && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2907           && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2908           && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2909 }
2910
2911 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
2912    the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2913
2914    Returns the new TYPENAME_TYPE.  */
2915
2916 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2917
2918 static tree
2919 build_typename_type (tree context, tree name, tree fullname,
2920                      enum tag_types tag_type)
2921 {
2922   tree t;
2923   tree d;
2924   typename_info ti;
2925   void **e;
2926   hashval_t hash;
2927
2928   if (typename_htab == NULL)
2929     typename_htab = htab_create_ggc (61, &typename_hash,
2930                                      &typename_compare, NULL);
2931
2932   ti.scope = FROB_CONTEXT (context);
2933   ti.name = name;
2934   ti.template_id = fullname;
2935   ti.enum_p = tag_type == enum_type;
2936   ti.class_p = (tag_type == class_type
2937                 || tag_type == record_type
2938                 || tag_type == union_type);
2939   hash =  (htab_hash_pointer (ti.scope)
2940            ^ htab_hash_pointer (ti.name));
2941
2942   /* See if we already have this type.  */
2943   e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2944   if (*e)
2945     t = (tree) *e;
2946   else
2947     {
2948       /* Build the TYPENAME_TYPE.  */
2949       t = cxx_make_type (TYPENAME_TYPE);
2950       TYPE_CONTEXT (t) = ti.scope;
2951       TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2952       TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2953       TYPENAME_IS_CLASS_P (t) = ti.class_p;
2954
2955       /* Build the corresponding TYPE_DECL.  */
2956       d = build_decl (input_location, TYPE_DECL, name, t);
2957       TYPE_NAME (TREE_TYPE (d)) = d;
2958       TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2959       DECL_CONTEXT (d) = FROB_CONTEXT (context);
2960       DECL_ARTIFICIAL (d) = 1;
2961
2962       /* Store it in the hash table.  */
2963       *e = t;
2964
2965       /* TYPENAME_TYPEs must always be compared structurally, because
2966          they may or may not resolve down to another type depending on
2967          the currently open classes. */
2968       SET_TYPE_STRUCTURAL_EQUALITY (t);
2969     }
2970
2971   return t;
2972 }
2973
2974 /* Resolve `typename CONTEXT::NAME'.  TAG_TYPE indicates the tag
2975    provided to name the type.  Returns an appropriate type, unless an
2976    error occurs, in which case error_mark_node is returned.  If we
2977    locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2978    return that, rather than the _TYPE it corresponds to, in other
2979    cases we look through the type decl.  If TF_ERROR is set, complain
2980    about errors, otherwise be quiet.  */
2981
2982 tree
2983 make_typename_type (tree context, tree name, enum tag_types tag_type,
2984                     tsubst_flags_t complain)
2985 {
2986   tree fullname;
2987   tree t;
2988   bool want_template;
2989
2990   if (name == error_mark_node
2991       || context == NULL_TREE
2992       || context == error_mark_node)
2993     return error_mark_node;
2994
2995   if (TYPE_P (name))
2996     {
2997       if (!(TYPE_LANG_SPECIFIC (name)
2998             && (CLASSTYPE_IS_TEMPLATE (name)
2999                 || CLASSTYPE_USE_TEMPLATE (name))))
3000         name = TYPE_IDENTIFIER (name);
3001       else
3002         /* Create a TEMPLATE_ID_EXPR for the type.  */
3003         name = build_nt (TEMPLATE_ID_EXPR,
3004                          CLASSTYPE_TI_TEMPLATE (name),
3005                          CLASSTYPE_TI_ARGS (name));
3006     }
3007   else if (TREE_CODE (name) == TYPE_DECL)
3008     name = DECL_NAME (name);
3009
3010   fullname = name;
3011
3012   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3013     {
3014       name = TREE_OPERAND (name, 0);
3015       if (TREE_CODE (name) == TEMPLATE_DECL)
3016         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
3017       else if (TREE_CODE (name) == OVERLOAD)
3018         {
3019           error ("%qD is not a type", name);
3020           return error_mark_node;
3021         }
3022     }
3023   if (TREE_CODE (name) == TEMPLATE_DECL)
3024     {
3025       error ("%qD used without template parameters", name);
3026       return error_mark_node;
3027     }
3028   gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3029   gcc_assert (TYPE_P (context));
3030
3031   if (!MAYBE_CLASS_TYPE_P (context))
3032     {
3033       if (complain & tf_error)
3034         error ("%q#T is not a class", context);
3035       return error_mark_node;
3036     }
3037   
3038   /* When the CONTEXT is a dependent type,  NAME could refer to a
3039      dependent base class of CONTEXT.  But look inside it anyway
3040      if CONTEXT is a currently open scope, in case it refers to a
3041      member of the current instantiation or a non-dependent base;
3042      lookup will stop when we hit a dependent base.  */
3043   if (!dependent_scope_p (context))
3044     /* We should only set WANT_TYPE when we're a nested typename type.
3045        Then we can give better diagnostics if we find a non-type.  */
3046     t = lookup_field (context, name, 2, /*want_type=*/true);
3047   else
3048     t = NULL_TREE;
3049
3050   if ((!t || TREE_CODE (t) == TREE_LIST) && dependent_type_p (context))
3051     return build_typename_type (context, name, fullname, tag_type);
3052
3053   want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3054   
3055   if (!t)
3056     {
3057       if (complain & tf_error)
3058         error (want_template ? "no class template named %q#T in %q#T"
3059                : "no type named %q#T in %q#T", name, context);
3060       return error_mark_node;
3061     }
3062   
3063   /* Pull out the template from an injected-class-name (or multiple).  */
3064   if (want_template)
3065     t = maybe_get_template_decl_from_type_decl (t);
3066
3067   if (TREE_CODE (t) == TREE_LIST)
3068     {
3069       if (complain & tf_error)
3070         {
3071           error ("lookup of %qT in %qT is ambiguous", name, context);
3072           print_candidates (t);
3073         }
3074       return error_mark_node;
3075     }
3076
3077   if (want_template && !DECL_CLASS_TEMPLATE_P (t))
3078     {
3079       if (complain & tf_error)
3080         error ("%<typename %T::%D%> names %q#T, which is not a class template",
3081                context, name, t);
3082       return error_mark_node;
3083     }
3084   if (!want_template && TREE_CODE (t) != TYPE_DECL)
3085     {
3086       if (complain & tf_error)
3087         error ("%<typename %T::%D%> names %q#T, which is not a type",
3088                context, name, t);
3089       return error_mark_node;
3090     }
3091   
3092   if (complain & tf_error)
3093     perform_or_defer_access_check (TYPE_BINFO (context), t, t);
3094
3095   /* If we are currently parsing a template and if T is a typedef accessed
3096      through CONTEXT then we need to remember and check access of T at
3097      template instantiation time.  */
3098   add_typedef_to_current_template_for_access_check (t, context, input_location);
3099
3100   if (want_template)
3101     return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3102                                   NULL_TREE, context,
3103                                   /*entering_scope=*/0,
3104                                   tf_warning_or_error | tf_user);
3105   
3106   if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3107     t = TREE_TYPE (t);
3108   
3109   return t;
3110 }
3111
3112 /* Resolve `CONTEXT::template NAME'.  Returns a TEMPLATE_DECL if the name
3113    can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3114    in which case error_mark_node is returned.
3115
3116    If PARM_LIST is non-NULL, also make sure that the template parameter
3117    list of TEMPLATE_DECL matches.
3118
3119    If COMPLAIN zero, don't complain about any errors that occur.  */
3120
3121 tree
3122 make_unbound_class_template (tree context, tree name, tree parm_list,
3123                              tsubst_flags_t complain)
3124 {
3125   tree t;
3126   tree d;
3127
3128   if (TYPE_P (name))
3129     name = TYPE_IDENTIFIER (name);
3130   else if (DECL_P (name))
3131     name = DECL_NAME (name);
3132   gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3133
3134   if (!dependent_type_p (context)
3135       || currently_open_class (context))
3136     {
3137       tree tmpl = NULL_TREE;
3138
3139       if (MAYBE_CLASS_TYPE_P (context))
3140         tmpl = lookup_field (context, name, 0, false);
3141
3142       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
3143         {
3144           if (complain & tf_error)
3145             error ("no class template named %q#T in %q#T", name, context);
3146           return error_mark_node;
3147         }
3148
3149       if (parm_list
3150           && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3151         {
3152           if (complain & tf_error)
3153             {
3154               error ("template parameters do not match template");
3155               error ("%q+D declared here", tmpl);
3156             }
3157           return error_mark_node;
3158         }
3159
3160       if (complain & tf_error)
3161         perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);
3162
3163       return tmpl;
3164     }
3165
3166   /* Build the UNBOUND_CLASS_TEMPLATE.  */
3167   t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3168   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3169   TREE_TYPE (t) = NULL_TREE;
3170   SET_TYPE_STRUCTURAL_EQUALITY (t);
3171
3172   /* Build the corresponding TEMPLATE_DECL.  */
3173   d = build_decl (input_location, TEMPLATE_DECL, name, t);
3174   TYPE_NAME (TREE_TYPE (d)) = d;
3175   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3176   DECL_CONTEXT (d) = FROB_CONTEXT (context);
3177   DECL_ARTIFICIAL (d) = 1;
3178   DECL_TEMPLATE_PARMS (d) = parm_list;
3179
3180   return t;
3181 }
3182
3183 \f
3184
3185 /* Push the declarations of builtin types into the namespace.
3186    RID_INDEX is the index of the builtin type in the array
3187    RID_POINTERS.  NAME is the name used when looking up the builtin
3188    type.  TYPE is the _TYPE node for the builtin type.  */
3189
3190 void
3191 record_builtin_type (enum rid rid_index,
3192                      const char* name,
3193                      tree type)
3194 {
3195   tree rname = NULL_TREE, tname = NULL_TREE;
3196   tree tdecl = NULL_TREE;
3197
3198   if ((int) rid_index < (int) RID_MAX)
3199     rname = ridpointers[(int) rid_index];
3200   if (name)
3201     tname = get_identifier (name);
3202
3203   /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3204      eliminated.  Built-in types should not be looked up name; their
3205      names are keywords that the parser can recognize.  However, there
3206      is code in c-common.c that uses identifier_global_value to look
3207      up built-in types by name.  */
3208   if (tname)
3209     {
3210       tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type);
3211       DECL_ARTIFICIAL (tdecl) = 1;
3212       SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3213     }
3214   if (rname)
3215     {
3216       if (!tdecl)
3217         {
3218           tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type);
3219           DECL_ARTIFICIAL (tdecl) = 1;
3220         }
3221       SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3222     }
3223
3224   if (!TYPE_NAME (type))
3225     TYPE_NAME (type) = tdecl;
3226
3227   if (tdecl)
3228     debug_hooks->type_decl (tdecl, 0);
3229 }
3230
3231 /* Record one of the standard Java types.
3232  * Declare it as having the given NAME.
3233  * If SIZE > 0, it is the size of one of the integral types;
3234  * otherwise it is the negative of the size of one of the other types.  */
3235
3236 static tree
3237 record_builtin_java_type (const char* name, int size)
3238 {
3239   tree type, decl;
3240   if (size > 0)
3241     type = build_nonstandard_integer_type (size, 0);
3242   else if (size > -32)
3243     {
3244       tree stype;
3245       /* "__java_char" or ""__java_boolean".  */
3246       type = build_nonstandard_integer_type (-size, 1);
3247       /* Get the signed type cached and attached to the unsigned type,
3248          so it doesn't get garbage-collected at "random" times,
3249          causing potential codegen differences out of different UIDs
3250          and different alias set numbers.  */
3251       stype = build_nonstandard_integer_type (-size, 0);
3252       TREE_CHAIN (type) = stype;
3253       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3254     }
3255   else
3256     { /* "__java_float" or ""__java_double".  */
3257       type = make_node (REAL_TYPE);
3258       TYPE_PRECISION (type) = - size;
3259       layout_type (type);
3260     }
3261   record_builtin_type (RID_MAX, name, type);
3262   decl = TYPE_NAME (type);
3263
3264   /* Suppress generate debug symbol entries for these types,
3265      since for normal C++ they are just clutter.
3266      However, push_lang_context undoes this if extern "Java" is seen.  */
3267   DECL_IGNORED_P (decl) = 1;
3268
3269   TYPE_FOR_JAVA (type) = 1;
3270   return type;
3271 }
3272
3273 /* Push a type into the namespace so that the back ends ignore it.  */
3274
3275 static void
3276 record_unknown_type (tree type, const char* name)
3277 {
3278   tree decl = pushdecl (build_decl (UNKNOWN_LOCATION,
3279                                     TYPE_DECL, get_identifier (name), type));
3280   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
3281   DECL_IGNORED_P (decl) = 1;
3282   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3283   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3284   TYPE_ALIGN (type) = 1;
3285   TYPE_USER_ALIGN (type) = 0;
3286   SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3287 }
3288
3289 /* A string for which we should create an IDENTIFIER_NODE at
3290    startup.  */
3291
3292 typedef struct predefined_identifier
3293 {
3294   /* The name of the identifier.  */
3295   const char *const name;
3296   /* The place where the IDENTIFIER_NODE should be stored.  */
3297   tree *const node;
3298   /* Nonzero if this is the name of a constructor or destructor.  */
3299   const int ctor_or_dtor_p;
3300 } predefined_identifier;
3301
3302 /* Create all the predefined identifiers.  */
3303
3304 static void
3305 initialize_predefined_identifiers (void)
3306 {
3307   const predefined_identifier *pid;
3308
3309   /* A table of identifiers to create at startup.  */
3310   static const predefined_identifier predefined_identifiers[] = {
3311     { "C++", &lang_name_cplusplus, 0 },
3312     { "C", &lang_name_c, 0 },
3313     { "Java", &lang_name_java, 0 },
3314     /* Some of these names have a trailing space so that it is
3315        impossible for them to conflict with names written by users.  */
3316     { "__ct ", &ctor_identifier, 1 },
3317     { "__base_ctor ", &base_ctor_identifier, 1 },
3318     { "__comp_ctor ", &complete_ctor_identifier, 1 },
3319     { "__dt ", &dtor_identifier, 1 },
3320     { "__comp_dtor ", &complete_dtor_identifier, 1 },
3321     { "__base_dtor ", &base_dtor_identifier, 1 },
3322     { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3323     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3324     { "nelts", &nelts_identifier, 0 },
3325     { THIS_NAME, &this_identifier, 0 },
3326     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3327     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3328     { "_vptr", &vptr_identifier, 0 },
3329     { "__vtt_parm", &vtt_parm_identifier, 0 },
3330     { "::", &global_scope_name, 0 },
3331     { "std", &std_identifier, 0 },
3332     { NULL, NULL, 0 }
3333   };
3334
3335   for (pid = predefined_identifiers; pid->name; ++pid)
3336     {
3337       *pid->node = get_identifier (pid->name);
3338       if (pid->ctor_or_dtor_p)
3339         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3340     }
3341 }
3342
3343 /* Create the predefined scalar types of C,
3344    and some nodes representing standard constants (0, 1, (void *)0).
3345    Initialize the global binding level.
3346    Make definitions for built-in primitive functions.  */
3347
3348 void
3349 cxx_init_decl_processing (void)
3350 {
3351   tree void_ftype;
3352   tree void_ftype_ptr;
3353
3354   build_common_tree_nodes (flag_signed_char, false);
3355
3356   /* Create all the identifiers we need.  */
3357   initialize_predefined_identifiers ();
3358
3359   /* Create the global variables.  */
3360   push_to_top_level ();
3361
3362   current_function_decl = NULL_TREE;
3363   current_binding_level = NULL;
3364   /* Enter the global namespace.  */
3365   gcc_assert (global_namespace == NULL_TREE);
3366   global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3367                                       void_type_node);
3368   TREE_PUBLIC (global_namespace) = 1;
3369   begin_scope (sk_namespace, global_namespace);
3370
3371   current_lang_name = NULL_TREE;
3372
3373   if (flag_visibility_ms_compat)
3374     default_visibility = VISIBILITY_HIDDEN;
3375
3376   /* Initially, C.  */
3377   current_lang_name = lang_name_c;
3378
3379   /* Create the `std' namespace.  */
3380   push_namespace (std_identifier);
3381   std_node = current_namespace;
3382   pop_namespace ();
3383
3384   c_common_nodes_and_builtins ();
3385
3386   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3387   java_short_type_node = record_builtin_java_type ("__java_short", 16);
3388   java_int_type_node = record_builtin_java_type ("__java_int", 32);
3389   java_long_type_node = record_builtin_java_type ("__java_long", 64);
3390   java_float_type_node = record_builtin_java_type ("__java_float", -32);
3391   java_double_type_node = record_builtin_java_type ("__java_double", -64);
3392   java_char_type_node = record_builtin_java_type ("__java_char", -16);
3393   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3394
3395   integer_two_node = build_int_cst (NULL_TREE, 2);
3396   integer_three_node = build_int_cst (NULL_TREE, 3);
3397
3398   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3399   truthvalue_type_node = boolean_type_node;
3400   truthvalue_false_node = boolean_false_node;
3401   truthvalue_true_node = boolean_true_node;
3402
3403   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3404
3405 #if 0
3406   record_builtin_type (RID_MAX, NULL, string_type_node);
3407 #endif
3408
3409   delta_type_node = ptrdiff_type_node;
3410   vtable_index_type = ptrdiff_type_node;
3411
3412   vtt_parm_type = build_pointer_type (const_ptr_type_node);
3413   void_ftype = build_function_type (void_type_node, void_list_node);
3414   void_ftype_ptr = build_function_type (void_type_node,
3415                                         tree_cons (NULL_TREE,
3416                                                    ptr_type_node,
3417                                                    void_list_node));
3418   void_ftype_ptr
3419     = build_exception_variant (void_ftype_ptr, empty_except_spec);
3420
3421   /* C++ extensions */
3422
3423   unknown_type_node = make_node (UNKNOWN_TYPE);
3424   record_unknown_type (unknown_type_node, "unknown type");
3425
3426   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
3427   TREE_TYPE (unknown_type_node) = unknown_type_node;
3428
3429   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3430      result.  */
3431   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3432   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3433
3434   init_list_type_node = make_node (UNKNOWN_TYPE);
3435   record_unknown_type (init_list_type_node, "init list");
3436
3437   {
3438     /* Make sure we get a unique function type, so we can give
3439        its pointer type a name.  (This wins for gdb.) */
3440     tree vfunc_type = make_node (FUNCTION_TYPE);
3441     TREE_TYPE (vfunc_type) = integer_type_node;
3442     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3443     layout_type (vfunc_type);
3444
3445     vtable_entry_type = build_pointer_type (vfunc_type);
3446   }
3447   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3448
3449   vtbl_type_node
3450     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3451   layout_type (vtbl_type_node);
3452   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3453   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3454   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3455   layout_type (vtbl_ptr_type_node);
3456   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3457
3458   push_namespace (get_identifier ("__cxxabiv1"));
3459   abi_node = current_namespace;
3460   pop_namespace ();
3461
3462   global_type_node = make_node (LANG_TYPE);
3463   record_unknown_type (global_type_node, "global type");
3464
3465   /* Now, C++.  */
3466   current_lang_name = lang_name_cplusplus;
3467
3468   {
3469     tree bad_alloc_id;
3470     tree bad_alloc_type_node;
3471     tree bad_alloc_decl;
3472     tree newtype, deltype;
3473     tree ptr_ftype_sizetype;
3474
3475     push_namespace (std_identifier);
3476     bad_alloc_id = get_identifier ("bad_alloc");
3477     bad_alloc_type_node = make_class_type (RECORD_TYPE);
3478     TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3479     bad_alloc_decl
3480       = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3481     DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3482     pop_namespace ();
3483
3484     ptr_ftype_sizetype
3485       = build_function_type (ptr_type_node,
3486                              tree_cons (NULL_TREE,
3487                                         size_type_node,
3488                                         void_list_node));