OSDN Git Service

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