OSDN Git Service

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