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