OSDN Git Service

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