OSDN Git Service

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