OSDN Git Service

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