OSDN Git Service

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