OSDN Git Service

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