OSDN Git Service

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