OSDN Git Service

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