OSDN Git Service

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