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