OSDN Git Service

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