gcc/cp/decl.c

   1 /* Process declarations and variables for C++ compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005  Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C++ front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "coretypes.h"
  34 #include "tm.h"
  35 #include "tree.h"
  36 #include "rtl.h"
  37 #include "expr.h"
  38 #include "flags.h"
  39 #include "cp-tree.h"
  40 #include "tree-inline.h"
  41 #include "decl.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "hashtab.h"
  46 #include "tm_p.h"
  47 #include "target.h"
  48 #include "c-common.h"
  49 #include "c-pragma.h"
  50 #include "diagnostic.h"
  51 #include "debug.h"
  52 #include "timevar.h"
  53 #include "tree-flow.h"
  54
  55 static tree grokparms (cp_parameter_declarator *, tree *);
  56 static const char *redeclaration_error_message (tree, tree);
  57
  58 static int decl_jump_unsafe (tree);
  59 static void require_complete_types_for_parms (tree);
  60 static int ambi_op_p (enum tree_code);
  61 static int unary_op_p (enum tree_code);
  62 static void push_local_name (tree);
  63 static tree grok_reference_init (tree, tree, tree, tree *);
  64 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
  65                          int, int, tree);
  66 static void record_unknown_type (tree, const char *);
  67 static tree builtin_function_1 (const char *, tree, tree,
  68                                 enum built_in_function code,
  69                                 enum built_in_class cl, const char *,
  70                                 tree);
  71 static tree build_library_fn_1 (tree, enum tree_code, tree);
  72 static int member_function_or_else (tree, tree, enum overload_flags);
  73 static void bad_specifiers (tree, const char *, int, int, int, int,
  74                             int);
  75 static void check_for_uninitialized_const_var (tree);
  76 static hashval_t typename_hash (const void *);
  77 static int typename_compare (const void *, const void *);
  78 static tree local_variable_p_walkfn (tree *, int *, void *);
  79 static tree record_builtin_java_type (const char *, int);
  80 static const char *tag_name (enum tag_types);
  81 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
  82 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
  83 static tree make_label_decl (tree, int);
  84 static void use_label (tree);
  85 static void check_previous_goto_1 (tree, struct cp_binding_level *, tree,
  86                                    const location_t *);
  87 static void check_previous_goto (struct named_label_use_list *);
  88 static void check_switch_goto (struct cp_binding_level *);
  89 static void check_previous_gotos (tree);
  90 static void pop_label (tree, tree);
  91 static void pop_labels (tree);
  92 static void maybe_deduce_size_from_array_init (tree, tree);
  93 static void layout_var_decl (tree);
  94 static void maybe_commonize_var (tree);
  95 static tree check_initializer (tree, tree, int, tree *);
  96 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
  97 static void save_function_data (tree);
  98 static void check_function_type (tree, tree);
  99 static void finish_constructor_body (void);
 100 static void begin_destructor_body (void);
 101 static void finish_destructor_body (void);
 102 static tree create_array_type_for_decl (tree, tree, tree);
 103 static tree get_atexit_node (void);
 104 static tree get_dso_handle_node (void);
 105 static tree start_cleanup_fn (void);
 106 static void end_cleanup_fn (void);
 107 static tree cp_make_fname_decl (tree, int);
 108 static void initialize_predefined_identifiers (void);
 109 static tree check_special_function_return_type
 110         (special_function_kind, tree, tree);
 111 static tree push_cp_library_fn (enum tree_code, tree);
 112 static tree build_cp_library_fn (tree, enum tree_code, tree);
 113 static void store_parm_decls (tree);
 114 static void initialize_local_var (tree, tree);
 115 static void expand_static_init (tree, tree);
 116 static tree next_initializable_field (tree);
 117 static tree reshape_init (tree, tree *);
 118
 119 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 120 tree error_mark_list;
 121
 122 /* The following symbols are subsumed in the cp_global_trees array, and
 123    listed here individually for documentation purposes.
 124
 125    C++ extensions
 126         tree wchar_decl_node;
 127
 128         tree vtable_entry_type;
 129         tree delta_type_node;
 130         tree __t_desc_type_node;
 131         tree ti_desc_type_node;
 132         tree bltn_desc_type_node, ptr_desc_type_node;
 133         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 134         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 135         tree ptm_desc_type_node;
 136         tree base_desc_type_node;
 137
 138         tree class_type_node;
 139         tree unknown_type_node;
 140
 141    Array type `vtable_entry_type[]'
 142
 143         tree vtbl_type_node;
 144         tree vtbl_ptr_type_node;
 145
 146    Namespaces,
 147
 148         tree std_node;
 149         tree abi_node;
 150
 151    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 152    one that the user will declare, but sufficient to be called
 153    by routines that want to abort the program.
 154
 155         tree abort_fndecl;
 156
 157    The FUNCTION_DECL for the default `::operator delete'.
 158
 159         tree global_delete_fndecl;
 160
 161    Used by RTTI
 162         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 163         tree tinfo_var_id;
 164
 165 */
 166
 167 tree cp_global_trees[CPTI_MAX];
 168
 169 /* Indicates that there is a type value in some namespace, although
 170    that is not necessarily in scope at the moment.  */
 171
 172 tree global_type_node;
 173
 174 /* The node that holds the "name" of the global scope.  */
 175 tree global_scope_name;
 176
 177 /* Used only for jumps to as-yet undefined labels, since jumps to
 178    defined labels can have their validity checked immediately.  */
 179
 180 struct named_label_use_list GTY(())
 181 {
 182   struct cp_binding_level *binding_level;
 183   tree names_in_scope;
 184   tree label_decl;
 185   location_t o_goto_locus;
 186   struct named_label_use_list *next;
 187 };
 188
 189 #define named_label_uses cp_function_chain->x_named_label_uses
 190
 191 #define local_names cp_function_chain->x_local_names
 192
 193 /* A list of objects which have constructors or destructors
 194    which reside in the global scope.  The decl is stored in
 195    the TREE_VALUE slot and the initializer is stored
 196    in the TREE_PURPOSE slot.  */
 197 tree static_aggregates;
 198
 199 /* -- end of C++ */
 200
 201 /* A node for the integer constants 2, and 3.  */
 202
 203 tree integer_two_node, integer_three_node;
 204
 205 /* A list of all LABEL_DECLs in the function that have names.  Here so
 206    we can clear out their names' definitions at the end of the
 207    function, and so we can check the validity of jumps to these labels.  */
 208
 209 struct named_label_list GTY(())
 210 {
 211   struct cp_binding_level *binding_level;
 212   tree names_in_scope;
 213   tree old_value;
 214   tree label_decl;
 215   tree bad_decls;
 216   struct named_label_list *next;
 217   unsigned int in_try_scope : 1;
 218   unsigned int in_catch_scope : 1;
 219 };
 220
 221 #define named_labels cp_function_chain->x_named_labels
 222 \f
 223 /* The number of function bodies which we are currently processing.
 224    (Zero if we are at namespace scope, one inside the body of a
 225    function, two inside the body of a function in a local class, etc.)  */
 226 int function_depth;
 227
 228 /* States indicating how grokdeclarator() should handle declspecs marked
 229    with __attribute__((deprecated)).  An object declared as
 230    __attribute__((deprecated)) suppresses warnings of uses of other
 231    deprecated items.  */
 232
 233 enum deprecated_states {
 234   DEPRECATED_NORMAL,
 235   DEPRECATED_SUPPRESS
 236 };
 237
 238 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 239
 240 /* True if a declaration with an `extern' linkage specifier is being
 241    processed.  */
 242 bool have_extern_spec;
 243
 244 \f
 245 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
 246    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
 247    time the VAR_DECL was declared, the type was incomplete.  */
 248
 249 static GTY(()) tree incomplete_vars;
 250 \f
 251 /* Returns the kind of template specialization we are currently
 252    processing, given that it's declaration contained N_CLASS_SCOPES
 253    explicit scope qualifications.  */
 254
 255 tmpl_spec_kind
 256 current_tmpl_spec_kind (int n_class_scopes)
 257 {
 258   int n_template_parm_scopes = 0;
 259   int seen_specialization_p = 0;
 260   int innermost_specialization_p = 0;
 261   struct cp_binding_level *b;
 262
 263   /* Scan through the template parameter scopes.  */
 264   for (b = current_binding_level;
 265        b->kind == sk_template_parms;
 266        b = b->level_chain)
 267     {
 268       /* If we see a specialization scope inside a parameter scope,
 269          then something is wrong.  That corresponds to a declaration
 270          like:
 271
 272             template <class T> template <> ...
 273
 274          which is always invalid since [temp.expl.spec] forbids the
 275          specialization of a class member template if the enclosing
 276          class templates are not explicitly specialized as well.  */
 277       if (b->explicit_spec_p)
 278         {
 279           if (n_template_parm_scopes == 0)
 280             innermost_specialization_p = 1;
 281           else
 282             seen_specialization_p = 1;
 283         }
 284       else if (seen_specialization_p == 1)
 285         return tsk_invalid_member_spec;
 286
 287       ++n_template_parm_scopes;
 288     }
 289
 290   /* Handle explicit instantiations.  */
 291   if (processing_explicit_instantiation)
 292     {
 293       if (n_template_parm_scopes != 0)
 294         /* We've seen a template parameter list during an explicit
 295            instantiation.  For example:
 296
 297              template <class T> template void f(int);
 298
 299            This is erroneous.  */
 300         return tsk_invalid_expl_inst;
 301       else
 302         return tsk_expl_inst;
 303     }
 304
 305   if (n_template_parm_scopes < n_class_scopes)
 306     /* We've not seen enough template headers to match all the
 307        specialized classes present.  For example:
 308
 309          template <class T> void R<T>::S<T>::f(int);
 310
 311        This is invalid; there needs to be one set of template
 312        parameters for each class.  */
 313     return tsk_insufficient_parms;
 314   else if (n_template_parm_scopes == n_class_scopes)
 315     /* We're processing a non-template declaration (even though it may
 316        be a member of a template class.)  For example:
 317
 318          template <class T> void S<T>::f(int);
 319
 320        The `class T' maches the `S<T>', leaving no template headers
 321        corresponding to the `f'.  */
 322     return tsk_none;
 323   else if (n_template_parm_scopes > n_class_scopes + 1)
 324     /* We've got too many template headers.  For example:
 325
 326          template <> template <class T> void f (T);
 327
 328        There need to be more enclosing classes.  */
 329     return tsk_excessive_parms;
 330   else
 331     /* This must be a template.  It's of the form:
 332
 333          template <class T> template <class U> void S<T>::f(U);
 334
 335        This is a specialization if the innermost level was a
 336        specialization; otherwise it's just a definition of the
 337        template.  */
 338     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 339 }
 340
 341 /* Exit the current scope.  */
 342
 343 void
 344 finish_scope (void)
 345 {
 346   poplevel (0, 0, 0);
 347 }
 348
 349 /* When a label goes out of scope, check to see if that label was used
 350    in a valid manner, and issue any appropriate warnings or errors.  */
 351
 352 static void
 353 pop_label (tree label, tree old_value)
 354 {
 355   if (!processing_template_decl)
 356     {
 357       if (DECL_INITIAL (label) == NULL_TREE)
 358         {
 359           location_t location;
 360
 361           cp_error_at ("label %qD used but not defined", label);
 362 #ifdef USE_MAPPED_LOCATION
 363           location = input_location; /* FIXME want (input_filename, (line)0) */
 364 #else
 365           location.file = input_filename;
 366           location.line = 0;
 367 #endif
 368           /* Avoid crashing later.  */
 369           define_label (location, DECL_NAME (label));
 370         }
 371       else if (warn_unused_label && !TREE_USED (label))
 372         cp_warning_at ("label %qD defined but not used", label);
 373     }
 374
 375   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
 376 }
 377
 378 /* At the end of a function, all labels declared within the function
 379    go out of scope.  BLOCK is the top-level block for the
 380    function.  */
 381
 382 static void
 383 pop_labels (tree block)
 384 {
 385   struct named_label_list *link;
 386
 387   /* Clear out the definitions of all label names, since their scopes
 388      end here.  */
 389   for (link = named_labels; link; link = link->next)
 390     {
 391       pop_label (link->label_decl, link->old_value);
 392       /* Put the labels into the "variables" of the top-level block,
 393          so debugger can see them.  */
 394       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
 395       BLOCK_VARS (block) = link->label_decl;
 396     }
 397
 398   named_labels = NULL;
 399 }
 400
 401 /* The following two routines are used to interface to Objective-C++.
 402    The binding level is purposely treated as an opaque type.  */
 403
 404 void *
 405 objc_get_current_scope (void)
 406 {
 407   return current_binding_level;
 408 }
 409
 410 /* The following routine is used by the NeXT-style SJLJ exceptions;
 411    variables get marked 'volatile' so as to not be clobbered by
 412    _setjmp()/_longjmp() calls.  All variables in the current scope,
 413    as well as parent scopes up to (but not including) ENCLOSING_BLK
 414    shall be thusly marked.  */
 415
 416 void
 417 objc_mark_locals_volatile (void *enclosing_blk)
 418 {
 419   struct cp_binding_level *scope;
 420
 421   for (scope = current_binding_level;
 422        scope && scope != enclosing_blk && scope->kind == sk_block;
 423        scope = scope->level_chain)
 424     {
 425       tree decl;
 426
 427       for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
 428         {
 429           if (TREE_CODE (decl) == VAR_DECL)
 430             {
 431               DECL_REGISTER (decl) = 0;
 432               TREE_THIS_VOLATILE (decl) = 1;
 433             }
 434         }
 435     }
 436 }
 437
 438 /* Exit a binding level.
 439    Pop the level off, and restore the state of the identifier-decl mappings
 440    that were in effect when this level was entered.
 441
 442    If KEEP == 1, this level had explicit declarations, so
 443    and create a "block" (a BLOCK node) for the level
 444    to record its declarations and subblocks for symbol table output.
 445
 446    If FUNCTIONBODY is nonzero, this level is the body of a function,
 447    so create a block as if KEEP were set and also clear out all
 448    label names.
 449
 450    If REVERSE is nonzero, reverse the order of decls before putting
 451    them into the BLOCK.  */
 452
 453 tree
 454 poplevel (int keep, int reverse, int functionbody)
 455 {
 456   tree link;
 457   /* The chain of decls was accumulated in reverse order.
 458      Put it into forward order, just for cleanliness.  */
 459   tree decls;
 460   int tmp = functionbody;
 461   int real_functionbody;
 462   tree subblocks;
 463   tree block;
 464   tree decl;
 465   int leaving_for_scope;
 466   scope_kind kind;
 467
 468   timevar_push (TV_NAME_LOOKUP);
 469  restart:
 470
 471   block = NULL_TREE;
 472
 473   gcc_assert (current_binding_level->kind != sk_class);
 474
 475   real_functionbody = (current_binding_level->kind == sk_cleanup
 476                        ? ((functionbody = 0), tmp) : functionbody);
 477   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
 478
 479   gcc_assert (!VEC_length(cp_class_binding,
 480                           current_binding_level->class_shadowed));
 481
 482   /* We used to use KEEP == 2 to indicate that the new block should go
 483      at the beginning of the list of blocks at this binding level,
 484      rather than the end.  This hack is no longer used.  */
 485   gcc_assert (keep == 0 || keep == 1);
 486
 487   if (current_binding_level->keep)
 488     keep = 1;
 489
 490   /* Any uses of undefined labels, and any defined labels, now operate
 491      under constraints of next binding contour.  */
 492   if (cfun && !functionbody)
 493     {
 494       struct cp_binding_level *level_chain;
 495       level_chain = current_binding_level->level_chain;
 496       if (level_chain)
 497         {
 498           struct named_label_use_list *uses;
 499           struct named_label_list *labels;
 500           for (labels = named_labels; labels; labels = labels->next)
 501             if (labels->binding_level == current_binding_level)
 502               {
 503                 tree decl;
 504                 if (current_binding_level->kind == sk_try)
 505                   labels->in_try_scope = 1;
 506                 if (current_binding_level->kind == sk_catch)
 507                   labels->in_catch_scope = 1;
 508                 for (decl = labels->names_in_scope; decl;
 509                      decl = TREE_CHAIN (decl))
 510                   if (decl_jump_unsafe (decl))
 511                     labels->bad_decls = tree_cons (NULL_TREE, decl,
 512                                                    labels->bad_decls);
 513                 labels->binding_level = level_chain;
 514                 labels->names_in_scope = level_chain->names;
 515               }
 516
 517           for (uses = named_label_uses; uses; uses = uses->next)
 518             if (uses->binding_level == current_binding_level)
 519               {
 520                 uses->binding_level = level_chain;
 521                 uses->names_in_scope = level_chain->names;
 522               }
 523         }
 524     }
 525
 526   /* Get the decls in the order they were written.
 527      Usually current_binding_level->names is in reverse order.
 528      But parameter decls were previously put in forward order.  */
 529
 530   if (reverse)
 531     current_binding_level->names
 532       = decls = nreverse (current_binding_level->names);
 533   else
 534     decls = current_binding_level->names;
 535
 536   /* If there were any declarations or structure tags in that level,
 537      or if this level is a function body,
 538      create a BLOCK to record them for the life of this function.  */
 539   block = NULL_TREE;
 540   if (keep == 1 || functionbody)
 541     block = make_node (BLOCK);
 542   if (block != NULL_TREE)
 543     {
 544       BLOCK_VARS (block) = decls;
 545       BLOCK_SUBBLOCKS (block) = subblocks;
 546     }
 547
 548   /* In each subblock, record that this is its superior.  */
 549   if (keep >= 0)
 550     for (link = subblocks; link; link = TREE_CHAIN (link))
 551       BLOCK_SUPERCONTEXT (link) = block;
 552
 553   /* We still support the old for-scope rules, whereby the variables
 554      in a for-init statement were in scope after the for-statement
 555      ended.  We only use the new rules if flag_new_for_scope is
 556      nonzero.  */
 557   leaving_for_scope
 558     = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
 559
 560   /* Before we remove the declarations first check for unused variables.  */
 561   if (warn_unused_variable
 562       && !processing_template_decl)
 563     for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
 564       if (TREE_CODE (decl) == VAR_DECL
 565           && ! TREE_USED (decl)
 566           && ! DECL_IN_SYSTEM_HEADER (decl)
 567           && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
 568         warning ("%Junused variable %qD", decl, decl);
 569
 570   /* Remove declarations for all the DECLs in this level.  */
 571   for (link = decls; link; link = TREE_CHAIN (link))
 572     {
 573       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
 574           && DECL_NAME (link))
 575         {
 576           tree name = DECL_NAME (link);
 577           cxx_binding *ob;
 578           tree ns_binding;
 579
 580           ob = outer_binding (name,
 581                               IDENTIFIER_BINDING (name),
 582                               /*class_p=*/true);
 583           if (!ob)
 584             ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
 585           else
 586             ns_binding = NULL_TREE;
 587
 588           if (ob && ob->scope == current_binding_level->level_chain)
 589             /* We have something like:
 590
 591                  int i;
 592                  for (int i; ;);
 593
 594                and we are leaving the `for' scope.  There's no reason to
 595                keep the binding of the inner `i' in this case.  */
 596             pop_binding (name, link);
 597           else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
 598                    || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
 599             /* Here, we have something like:
 600
 601                  typedef int I;
 602
 603                  void f () {
 604                    for (int I; ;);
 605                  }
 606
 607                We must pop the for-scope binding so we know what's a
 608                type and what isn't.  */
 609             pop_binding (name, link);
 610           else
 611             {
 612               /* Mark this VAR_DECL as dead so that we can tell we left it
 613                  there only for backward compatibility.  */
 614               DECL_DEAD_FOR_LOCAL (link) = 1;
 615
 616               /* Keep track of what should have happened when we
 617                  popped the binding.  */
 618               if (ob && ob->value)
 619                 DECL_SHADOWED_FOR_VAR (link) = ob->value;
 620
 621               /* Add it to the list of dead variables in the next
 622                  outermost binding to that we can remove these when we
 623                  leave that binding.  */
 624               current_binding_level->level_chain->dead_vars_from_for
 625                 = tree_cons (NULL_TREE, link,
 626                              current_binding_level->level_chain->
 627                              dead_vars_from_for);
 628
 629               /* Although we don't pop the cxx_binding, we do clear
 630                  its SCOPE since the scope is going away now.  */
 631               IDENTIFIER_BINDING (name)->scope
 632                 = current_binding_level->level_chain;
 633             }
 634         }
 635       else
 636         {
 637           tree name;
 638
 639           /* Remove the binding.  */
 640           decl = link;
 641
 642           if (TREE_CODE (decl) == TREE_LIST)
 643             decl = TREE_VALUE (decl);
 644           name = decl;
 645
 646           if (TREE_CODE (name) == OVERLOAD)
 647             name = OVL_FUNCTION (name);
 648
 649           gcc_assert (DECL_P (name));
 650           pop_binding (DECL_NAME (name), decl);
 651         }
 652     }
 653
 654   /* Remove declarations for any `for' variables from inner scopes
 655      that we kept around.  */
 656   for (link = current_binding_level->dead_vars_from_for;
 657        link; link = TREE_CHAIN (link))
 658     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
 659
 660   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
 661   for (link = current_binding_level->type_shadowed;
 662        link; link = TREE_CHAIN (link))
 663     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
 664
 665   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
 666   for (link = current_binding_level->shadowed_labels;
 667        link;
 668        link = TREE_CHAIN (link))
 669     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
 670
 671   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
 672      list if a `using' declaration put them there.  The debugging
 673      back-ends won't understand OVERLOAD, so we remove them here.
 674      Because the BLOCK_VARS are (temporarily) shared with
 675      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
 676      popped all the bindings.  */
 677   if (block)
 678     {
 679       tree* d;
 680
 681       for (d = &BLOCK_VARS (block); *d; )
 682         {
 683           if (TREE_CODE (*d) == TREE_LIST)
 684             *d = TREE_CHAIN (*d);
 685           else
 686             d = &TREE_CHAIN (*d);
 687         }
 688     }
 689
 690   /* If the level being exited is the top level of a function,
 691      check over all the labels.  */
 692   if (functionbody)
 693     {
 694       /* Since this is the top level block of a function, the vars are
 695          the function's parameters.  Don't leave them in the BLOCK
 696          because they are found in the FUNCTION_DECL instead.  */
 697       BLOCK_VARS (block) = 0;
 698       pop_labels (block);
 699     }
 700
 701   kind = current_binding_level->kind;
 702   if (kind == sk_cleanup)
 703     {
 704       tree stmt;
 705
 706       /* If this is a temporary binding created for a cleanup, then we'll
 707          have pushed a statement list level.  Pop that, create a new
 708          BIND_EXPR for the block, and insert it into the stream.  */
 709       stmt = pop_stmt_list (current_binding_level->statement_list);
 710       stmt = c_build_bind_expr (block, stmt);
 711       add_stmt (stmt);
 712     }
 713
 714   leave_scope ();
 715   if (functionbody)
 716     DECL_INITIAL (current_function_decl) = block;
 717   else if (block)
 718     current_binding_level->blocks
 719       = chainon (current_binding_level->blocks, block);
 720
 721   /* If we did not make a block for the level just exited,
 722      any blocks made for inner levels
 723      (since they cannot be recorded as subblocks in that level)
 724      must be carried forward so they will later become subblocks
 725      of something else.  */
 726   else if (subblocks)
 727     current_binding_level->blocks
 728       = chainon (current_binding_level->blocks, subblocks);
 729
 730   /* Each and every BLOCK node created here in `poplevel' is important
 731      (e.g. for proper debugging information) so if we created one
 732      earlier, mark it as "used".  */
 733   if (block)
 734     TREE_USED (block) = 1;
 735
 736   /* All temporary bindings created for cleanups are popped silently.  */
 737   if (kind == sk_cleanup)
 738     goto restart;
 739
 740   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
 741 }
 742
 743 /* Insert BLOCK at the end of the list of subblocks of the
 744    current binding level.  This is used when a BIND_EXPR is expanded,
 745    to handle the BLOCK node inside the BIND_EXPR.  */
 746
 747 void
 748 insert_block (tree block)
 749 {
 750   TREE_USED (block) = 1;
 751   current_binding_level->blocks
 752     = chainon (current_binding_level->blocks, block);
 753 }
 754
 755 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
 756    itself, calling F for each.  The DATA is passed to F as well.  */
 757
 758 static int
 759 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
 760 {
 761   int result = 0;
 762   tree current = NAMESPACE_LEVEL (namespace)->namespaces;
 763
 764   result |= (*f) (namespace, data);
 765
 766   for (; current; current = TREE_CHAIN (current))
 767     result |= walk_namespaces_r (current, f, data);
 768
 769   return result;
 770 }
 771
 772 /* Walk all the namespaces, calling F for each.  The DATA is passed to
 773    F as well.  */
 774
 775 int
 776 walk_namespaces (walk_namespaces_fn f, void* data)
 777 {
 778   return walk_namespaces_r (global_namespace, f, data);
 779 }
 780
 781 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
 782    DATA is non-NULL, this is the last time we will call
 783    wrapup_global_declarations for this NAMESPACE.  */
 784
 785 int
 786 wrapup_globals_for_namespace (tree namespace, void* data)
 787 {
 788   struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
 789   varray_type statics = level->static_decls;
 790   tree *vec = &VARRAY_TREE (statics, 0);
 791   int len = VARRAY_ACTIVE_SIZE (statics);
 792   int last_time = (data != 0);
 793
 794   if (last_time)
 795     {
 796       check_global_declarations (vec, len);
 797       return 0;
 798     }
 799
 800   /* Write out any globals that need to be output.  */
 801   return wrapup_global_declarations (vec, len);
 802 }
 803
 804 \f
 805 /* In C++, you don't have to write `struct S' to refer to `S'; you
 806    can just use `S'.  We accomplish this by creating a TYPE_DECL as
 807    if the user had written `typedef struct S S'.  Create and return
 808    the TYPE_DECL for TYPE.  */
 809
 810 tree
 811 create_implicit_typedef (tree name, tree type)
 812 {
 813   tree decl;
 814
 815   decl = build_decl (TYPE_DECL, name, type);
 816   DECL_ARTIFICIAL (decl) = 1;
 817   /* There are other implicit type declarations, like the one *within*
 818      a class that allows you to write `S::S'.  We must distinguish
 819      amongst these.  */
 820   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
 821   TYPE_NAME (type) = decl;
 822
 823   return decl;
 824 }
 825
 826 /* Remember a local name for name-mangling purposes.  */
 827
 828 static void
 829 push_local_name (tree decl)
 830 {
 831   size_t i, nelts;
 832   tree t, name;
 833
 834   timevar_push (TV_NAME_LOOKUP);
 835   if (!local_names)
 836     VARRAY_TREE_INIT (local_names, 8, "local_names");
 837
 838   name = DECL_NAME (decl);
 839
 840   nelts = VARRAY_ACTIVE_SIZE (local_names);
 841   for (i = 0; i < nelts; i++)
 842     {
 843       t = VARRAY_TREE (local_names, i);
 844       if (DECL_NAME (t) == name)
 845         {
 846           if (!DECL_LANG_SPECIFIC (decl))
 847             retrofit_lang_decl (decl);
 848           DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
 849           if (DECL_LANG_SPECIFIC (t))
 850             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
 851           else
 852             DECL_DISCRIMINATOR (decl) = 1;
 853
 854           VARRAY_TREE (local_names, i) = decl;
 855           timevar_pop (TV_NAME_LOOKUP);
 856           return;
 857         }
 858     }
 859
 860   VARRAY_PUSH_TREE (local_names, decl);
 861   timevar_pop (TV_NAME_LOOKUP);
 862 }
 863 \f
 864 /* Subroutine of duplicate_decls: return truthvalue of whether
 865    or not types of these decls match.
 866
 867    For C++, we must compare the parameter list so that `int' can match
 868    `int&' in a parameter position, but `int&' is not confused with
 869    `const int&'.  */
 870
 871 int
 872 decls_match (tree newdecl, tree olddecl)
 873 {
 874   int types_match;
 875
 876   if (newdecl == olddecl)
 877     return 1;
 878
 879   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
 880     /* If the two DECLs are not even the same kind of thing, we're not
 881        interested in their types.  */
 882     return 0;
 883
 884   if (TREE_CODE (newdecl) == FUNCTION_DECL)
 885     {
 886       tree f1 = TREE_TYPE (newdecl);
 887       tree f2 = TREE_TYPE (olddecl);
 888       tree p1 = TYPE_ARG_TYPES (f1);
 889       tree p2 = TYPE_ARG_TYPES (f2);
 890
 891       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
 892           && ! (DECL_EXTERN_C_P (newdecl)
 893                 && DECL_EXTERN_C_P (olddecl)))
 894         return 0;
 895
 896       if (TREE_CODE (f1) != TREE_CODE (f2))
 897         return 0;
 898
 899       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
 900         {
 901           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
 902               && (DECL_BUILT_IN (olddecl)
 903 #ifndef NO_IMPLICIT_EXTERN_C
 904                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
 905                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
 906 #endif
 907               ))
 908             {
 909               types_match = self_promoting_args_p (p1);
 910               if (p1 == void_list_node)
 911                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
 912             }
 913 #ifndef NO_IMPLICIT_EXTERN_C
 914           else if (p1 == NULL_TREE
 915                    && (DECL_EXTERN_C_P (olddecl)
 916                        && DECL_IN_SYSTEM_HEADER (olddecl)
 917                        && !DECL_CLASS_SCOPE_P (olddecl))
 918                    && (DECL_EXTERN_C_P (newdecl)
 919                        && DECL_IN_SYSTEM_HEADER (newdecl)
 920                        && !DECL_CLASS_SCOPE_P (newdecl)))
 921             {
 922               types_match = self_promoting_args_p (p2);
 923               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
 924             }
 925 #endif
 926           else
 927             types_match = compparms (p1, p2);
 928         }
 929       else
 930         types_match = 0;
 931     }
 932   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
 933     {
 934       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
 935           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
 936         return 0;
 937
 938       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
 939                                 DECL_TEMPLATE_PARMS (olddecl)))
 940         return 0;
 941
 942       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
 943         types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
 944                                    TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
 945       else
 946         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
 947                                    DECL_TEMPLATE_RESULT (newdecl));
 948     }
 949   else
 950     {
 951       /* Need to check scope for variable declaration (VAR_DECL).
 952          For typedef (TYPE_DECL), scope is ignored.  */
 953       if (TREE_CODE (newdecl) == VAR_DECL
 954           && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
 955         return 0;
 956
 957       if (TREE_TYPE (newdecl) == error_mark_node)
 958         types_match = TREE_TYPE (olddecl) == error_mark_node;
 959       else if (TREE_TYPE (olddecl) == NULL_TREE)
 960         types_match = TREE_TYPE (newdecl) == NULL_TREE;
 961       else if (TREE_TYPE (newdecl) == NULL_TREE)
 962         types_match = 0;
 963       else
 964         types_match = comptypes (TREE_TYPE (newdecl),
 965                                  TREE_TYPE (olddecl),
 966                                  COMPARE_REDECLARATION);
 967     }
 968
 969   return types_match;
 970 }
 971
 972 /* If NEWDECL is `static' and an `extern' was seen previously,
 973    warn about it.  OLDDECL is the previous declaration.
 974
 975    Note that this does not apply to the C++ case of declaring
 976    a variable `extern const' and then later `const'.
 977
 978    Don't complain about built-in functions, since they are beyond
 979    the user's control.  */
 980
 981 void
 982 warn_extern_redeclared_static (tree newdecl, tree olddecl)
 983 {
 984   tree name;
 985
 986   if (TREE_CODE (newdecl) == TYPE_DECL
 987       || TREE_CODE (newdecl) == TEMPLATE_DECL
 988       || TREE_CODE (newdecl) == CONST_DECL
 989       || TREE_CODE (newdecl) == NAMESPACE_DECL)
 990     return;
 991
 992   /* Don't get confused by static member functions; that's a different
 993      use of `static'.  */
 994   if (TREE_CODE (newdecl) == FUNCTION_DECL
 995       && DECL_STATIC_FUNCTION_P (newdecl))
 996     return;
 997
 998   /* If the old declaration was `static', or the new one isn't, then
 999      then everything is OK.  */
1000   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1001     return;
1002
1003   /* It's OK to declare a builtin function as `static'.  */
1004   if (TREE_CODE (olddecl) == FUNCTION_DECL
1005       && DECL_ARTIFICIAL (olddecl))
1006     return;
1007
1008   name = DECL_ASSEMBLER_NAME (newdecl);
1009   pedwarn ("%qD was declared %<extern%> and later %<static%>", newdecl);
1010   cp_pedwarn_at ("previous declaration of %qD", olddecl);
1011 }
1012
1013 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1014    If the redeclaration is invalid, a diagnostic is issued, and the
1015    error_mark_node is returned.  Otherwise, OLDDECL is returned.
1016
1017    If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1018    returned.  */
1019
1020 tree
1021 duplicate_decls (tree newdecl, tree olddecl)
1022 {
1023   unsigned olddecl_uid = DECL_UID (olddecl);
1024   int olddecl_friend = 0, types_match = 0;
1025   int new_defines_function = 0;
1026
1027   if (newdecl == olddecl)
1028     return olddecl;
1029
1030   types_match = decls_match (newdecl, olddecl);
1031
1032   /* If either the type of the new decl or the type of the old decl is an
1033      error_mark_node, then that implies that we have already issued an
1034      error (earlier) for some bogus type specification, and in that case,
1035      it is rather pointless to harass the user with yet more error message
1036      about the same declaration, so just pretend the types match here.  */
1037   if (TREE_TYPE (newdecl) == error_mark_node
1038       || TREE_TYPE (olddecl) == error_mark_node)
1039     types_match = 1;
1040
1041   if (DECL_P (olddecl)
1042       && TREE_CODE (newdecl) == FUNCTION_DECL
1043       && TREE_CODE (olddecl) == FUNCTION_DECL
1044       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1045     {
1046       if (DECL_DECLARED_INLINE_P (newdecl)
1047           && DECL_UNINLINABLE (newdecl)
1048           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1049         /* Already warned elsewhere.  */;
1050       else if (DECL_DECLARED_INLINE_P (olddecl)
1051                && DECL_UNINLINABLE (olddecl)
1052                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1053         /* Already warned.  */;
1054       else if (DECL_DECLARED_INLINE_P (newdecl)
1055                && DECL_UNINLINABLE (olddecl)
1056                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1057         {
1058           warning ("%Jfunction %qD redeclared as inline", newdecl, newdecl);
1059           warning ("%Jprevious declaration of %qD with attribute noinline",
1060                    olddecl, olddecl);
1061         }
1062       else if (DECL_DECLARED_INLINE_P (olddecl)
1063                && DECL_UNINLINABLE (newdecl)
1064                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1065         {
1066           warning ("%Jfunction %qD redeclared with attribute noinline",
1067                    newdecl, newdecl);
1068           warning ("%Jprevious declaration of %qD was inline",
1069                    olddecl, olddecl);
1070         }
1071     }
1072
1073   /* Check for redeclaration and other discrepancies.  */
1074   if (TREE_CODE (olddecl) == FUNCTION_DECL
1075       && DECL_ARTIFICIAL (olddecl))
1076     {
1077       if (TREE_CODE (newdecl) != FUNCTION_DECL)
1078         {
1079           /* Avoid warnings redeclaring anticipated built-ins.  */
1080           if (DECL_ANTICIPATED (olddecl))
1081             return NULL_TREE;
1082
1083           /* If you declare a built-in or predefined function name as static,
1084              the old definition is overridden, but optionally warn this was a
1085              bad choice of name.  */
1086           if (! TREE_PUBLIC (newdecl))
1087             {
1088               if (warn_shadow)
1089                 warning ("shadowing %s function %q#D",
1090                          DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1091                          olddecl);
1092               /* Discard the old built-in function.  */
1093               return NULL_TREE;
1094             }
1095           /* If the built-in is not ansi, then programs can override
1096              it even globally without an error.  */
1097           else if (! DECL_BUILT_IN (olddecl))
1098             warning ("library function %q#D redeclared as non-function %q#D",
1099                      olddecl, newdecl);
1100           else
1101             {
1102               error ("declaration of %q#D", newdecl);
1103               error ("conflicts with built-in declaration %q#D",
1104                      olddecl);
1105             }
1106           return NULL_TREE;
1107         }
1108       else if (!types_match)
1109         {
1110           /* Avoid warnings redeclaring anticipated built-ins.  */
1111           if (DECL_ANTICIPATED (olddecl))
1112             {
1113               /* Deal with fileptr_type_node.  FILE type is not known
1114                  at the time we create the builtins.  */
1115               tree t1, t2;
1116
1117               for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1118                    t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1119                    t1 || t2;
1120                    t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1121                 if (!t1 || !t2)
1122                   break;
1123                 else if (TREE_VALUE (t2) == fileptr_type_node)
1124                   {
1125                     tree t = TREE_VALUE (t1);
1126
1127                     if (TREE_CODE (t) == POINTER_TYPE
1128                         && TYPE_NAME (TREE_TYPE (t))
1129                         && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1130                            == get_identifier ("FILE")
1131                         && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1132                       {
1133                         tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1134
1135                         TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1136                           = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1137                         types_match = decls_match (newdecl, olddecl);
1138                         if (types_match)
1139                           return duplicate_decls (newdecl, olddecl);
1140                         TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1141                       }
1142                   }
1143                 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1144                   break;
1145             }
1146           else if ((DECL_EXTERN_C_P (newdecl)
1147                     && DECL_EXTERN_C_P (olddecl))
1148                    || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1149                                  TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1150             {
1151               /* A near match; override the builtin.  */
1152
1153               if (TREE_PUBLIC (newdecl))
1154                 {
1155                   warning ("new declaration %q#D", newdecl);
1156                   warning ("ambiguates built-in declaration %q#D",
1157                            olddecl);
1158                 }
1159               else if (warn_shadow)
1160                 warning ("shadowing %s function %q#D",
1161                          DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1162                          olddecl);
1163             }
1164           else
1165             /* Discard the old built-in function.  */
1166             return NULL_TREE;
1167
1168           /* Replace the old RTL to avoid problems with inlining.  */
1169           COPY_DECL_RTL (newdecl, olddecl);
1170         }
1171       /* Even if the types match, prefer the new declarations type
1172          for anticipated built-ins, for exception lists, etc...  */
1173       else if (DECL_ANTICIPATED (olddecl))
1174         {
1175           tree type = TREE_TYPE (newdecl);
1176           tree attribs = (*targetm.merge_type_attributes)
1177             (TREE_TYPE (olddecl), type);
1178
1179           type = cp_build_type_attribute_variant (type, attribs);
1180           TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1181         }
1182
1183       /* Whether or not the builtin can throw exceptions has no
1184          bearing on this declarator.  */
1185       TREE_NOTHROW (olddecl) = 0;
1186
1187       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1188         {
1189           /* If a builtin function is redeclared as `static', merge
1190              the declarations, but make the original one static.  */
1191           DECL_THIS_STATIC (olddecl) = 1;
1192           TREE_PUBLIC (olddecl) = 0;
1193
1194           /* Make the old declaration consistent with the new one so
1195              that all remnants of the builtin-ness of this function
1196              will be banished.  */
1197           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1198           COPY_DECL_RTL (newdecl, olddecl);
1199         }
1200     }
1201   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1202     {
1203       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1204            && TREE_CODE (newdecl) != TYPE_DECL
1205            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
1206                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
1207           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1208               && TREE_CODE (olddecl) != TYPE_DECL
1209               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
1210                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1211                         == TYPE_DECL))))
1212         {
1213           /* We do nothing special here, because C++ does such nasty
1214              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
1215              get shadowed, and know that if we need to find a TYPE_DECL
1216              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1217              slot of the identifier.  */
1218           return NULL_TREE;
1219         }
1220
1221       if ((TREE_CODE (newdecl) == FUNCTION_DECL
1222            && DECL_FUNCTION_TEMPLATE_P (olddecl))
1223           || (TREE_CODE (olddecl) == FUNCTION_DECL
1224               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1225         return NULL_TREE;
1226
1227       error ("%q#D redeclared as different kind of symbol", newdecl);
1228       if (TREE_CODE (olddecl) == TREE_LIST)
1229         olddecl = TREE_VALUE (olddecl);
1230       cp_error_at ("previous declaration of %q#D", olddecl);
1231
1232       return error_mark_node;
1233     }
1234   else if (!types_match)
1235     {
1236       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1237         /* These are certainly not duplicate declarations; they're
1238            from different scopes.  */
1239         return NULL_TREE;
1240
1241       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1242         {
1243           /* The name of a class template may not be declared to refer to
1244              any other template, class, function, object, namespace, value,
1245              or type in the same scope.  */
1246           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1247               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1248             {
1249               error ("declaration of template %q#D", newdecl);
1250               cp_error_at ("conflicts with previous declaration %q#D",
1251                            olddecl);
1252             }
1253           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1254                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1255                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1256                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1257                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1258                                            DECL_TEMPLATE_PARMS (olddecl))
1259                    /* Template functions can be disambiguated by
1260                       return type.  */
1261                    && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1262                                    TREE_TYPE (TREE_TYPE (olddecl))))
1263             {
1264               error ("new declaration %q#D", newdecl);
1265               cp_error_at ("ambiguates old declaration %q#D", olddecl);
1266             }
1267           return NULL_TREE;
1268         }
1269       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1270         {
1271           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1272             {
1273               error ("declaration of C function %q#D conflicts with",
1274                      newdecl);
1275               cp_error_at ("previous declaration %q#D here", olddecl);
1276             }
1277           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1278                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1279             {
1280               error ("new declaration %q#D", newdecl);
1281               cp_error_at ("ambiguates old declaration %q#D", olddecl);
1282             }
1283           else
1284             return NULL_TREE;
1285         }
1286       else
1287         {
1288           error ("conflicting declaration %q#D", newdecl);
1289           cp_error_at ("%qD has a previous declaration as %q#D",
1290                        olddecl, olddecl);
1291           return error_mark_node;
1292         }
1293     }
1294   else if (TREE_CODE (newdecl) == FUNCTION_DECL
1295             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1296                  && (!DECL_TEMPLATE_INFO (newdecl)
1297                      || (DECL_TI_TEMPLATE (newdecl)
1298                          != DECL_TI_TEMPLATE (olddecl))))
1299                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1300                     && (!DECL_TEMPLATE_INFO (olddecl)
1301                         || (DECL_TI_TEMPLATE (olddecl)
1302                             != DECL_TI_TEMPLATE (newdecl))))))
1303     /* It's OK to have a template specialization and a non-template
1304        with the same type, or to have specializations of two
1305        different templates with the same type.  Note that if one is a
1306        specialization, and the other is an instantiation of the same
1307        template, that we do not exit at this point.  That situation
1308        can occur if we instantiate a template class, and then
1309        specialize one of its methods.  This situation is valid, but
1310        the declarations must be merged in the usual way.  */
1311     return NULL_TREE;
1312   else if (TREE_CODE (newdecl) == FUNCTION_DECL
1313            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1314                 && !DECL_USE_TEMPLATE (newdecl))
1315                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1316                    && !DECL_USE_TEMPLATE (olddecl))))
1317     /* One of the declarations is a template instantiation, and the
1318        other is not a template at all.  That's OK.  */
1319     return NULL_TREE;
1320   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1321     {
1322       /* In [namespace.alias] we have:
1323
1324            In a declarative region, a namespace-alias-definition can be
1325            used to redefine a namespace-alias declared in that declarative
1326            region to refer only to the namespace to which it already
1327            refers.
1328
1329          Therefore, if we encounter a second alias directive for the same
1330          alias, we can just ignore the second directive.  */
1331       if (DECL_NAMESPACE_ALIAS (newdecl)
1332           && (DECL_NAMESPACE_ALIAS (newdecl)
1333               == DECL_NAMESPACE_ALIAS (olddecl)))
1334         return olddecl;
1335       /* [namespace.alias]
1336
1337          A namespace-name or namespace-alias shall not be declared as
1338          the name of any other entity in the same declarative region.
1339          A namespace-name defined at global scope shall not be
1340          declared as the name of any other entity in any global scope
1341          of the program.  */
1342       error ("declaration of namespace %qD conflicts with", newdecl);
1343       cp_error_at ("previous declaration of namespace %qD here", olddecl);
1344       return error_mark_node;
1345     }
1346   else
1347     {
1348       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1349       if (errmsg)
1350         {
1351           error (errmsg, newdecl);
1352           if (DECL_NAME (olddecl) != NULL_TREE)
1353             cp_error_at ((DECL_INITIAL (olddecl)
1354                           && namespace_bindings_p ())
1355                          ? "%q#D previously defined here"
1356                          : "%q#D previously declared here", olddecl);
1357           return error_mark_node;
1358         }
1359       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1360                && DECL_INITIAL (olddecl) != NULL_TREE
1361                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1362                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1363         {
1364           /* Prototype decl follows defn w/o prototype.  */
1365           cp_warning_at ("prototype for %q#D", newdecl);
1366           warning ("%Jfollows non-prototype definition here", olddecl);
1367         }
1368       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1369                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1370         {
1371           /* extern "C" int foo ();
1372              int foo () { bar (); }
1373              is OK.  */
1374           if (current_lang_depth () == 0)
1375             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1376           else
1377             {
1378               cp_error_at ("previous declaration of %q#D with %qL linkage",
1379                            olddecl, DECL_LANGUAGE (olddecl));
1380               error ("conflicts with new declaration with %qL linkage",
1381                      DECL_LANGUAGE (newdecl));
1382             }
1383         }
1384
1385       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1386         ;
1387       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1388         {
1389           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1390           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1391           int i = 1;
1392
1393           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1394             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1395
1396           for (; t1 && t1 != void_list_node;
1397                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1398             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1399               {
1400                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1401                                            TREE_PURPOSE (t2)))
1402                   {
1403                     pedwarn ("default argument given for parameter %d of %q#D",
1404                              i, newdecl);
1405                     cp_pedwarn_at ("after previous specification in %q#D",
1406                                    olddecl);
1407                   }
1408                 else
1409                   {
1410                     error ("default argument given for parameter %d of %q#D",
1411                            i, newdecl);
1412                     cp_error_at ("after previous specification in %q#D",
1413                                  olddecl);
1414                   }
1415               }
1416
1417           if (DECL_DECLARED_INLINE_P (newdecl)
1418               && ! DECL_DECLARED_INLINE_P (olddecl)
1419               && TREE_ADDRESSABLE (olddecl) && warn_inline)
1420             {
1421               warning ("%q#D was used before it was declared inline", newdecl);
1422               warning ("%Jprevious non-inline declaration here", olddecl);
1423             }
1424         }
1425     }
1426
1427   /* Do not merge an implicit typedef with an explicit one.  In:
1428
1429        class A;
1430        ...
1431        typedef class A A __attribute__ ((foo));
1432
1433      the attribute should apply only to the typedef.  */
1434   if (TREE_CODE (olddecl) == TYPE_DECL
1435       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1436           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1437     return NULL_TREE;
1438
1439   /* If new decl is `static' and an `extern' was seen previously,
1440      warn about it.  */
1441   warn_extern_redeclared_static (newdecl, olddecl);
1442
1443   /* We have committed to returning 1 at this point.  */
1444   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1445     {
1446       /* Now that functions must hold information normally held
1447          by field decls, there is extra work to do so that
1448          declaration information does not get destroyed during
1449          definition.  */
1450       if (DECL_VINDEX (olddecl))
1451         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1452       if (DECL_CONTEXT (olddecl))
1453         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1454       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1455       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1456       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1457       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1458       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1459       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1460         SET_OVERLOADED_OPERATOR_CODE
1461           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1462       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1463
1464       /* Optionally warn about more than one declaration for the same
1465          name, but don't warn about a function declaration followed by a
1466          definition.  */
1467       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1468           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1469           /* Don't warn about extern decl followed by definition.  */
1470           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1471           /* Don't warn about friends, let add_friend take care of it.  */
1472           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
1473         {
1474           warning ("redundant redeclaration of %qD in same scope", newdecl);
1475           cp_warning_at ("previous declaration of %qD", olddecl);
1476         }
1477     }
1478
1479   /* Deal with C++: must preserve virtual function table size.  */
1480   if (TREE_CODE (olddecl) == TYPE_DECL)
1481     {
1482       tree newtype = TREE_TYPE (newdecl);
1483       tree oldtype = TREE_TYPE (olddecl);
1484
1485       if (newtype != error_mark_node && oldtype != error_mark_node
1486           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1487         CLASSTYPE_FRIEND_CLASSES (newtype)
1488           = CLASSTYPE_FRIEND_CLASSES (oldtype);
1489
1490       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1491     }
1492
1493   /* Copy all the DECL_... slots specified in the new decl
1494      except for any that we copy here from the old type.  */
1495   DECL_ATTRIBUTES (newdecl)
1496     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1497
1498   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1499     {
1500       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
1501       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1502         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1503                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1504
1505       /* If the new declaration is a definition, update the file and
1506          line information on the declaration.  */
1507       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
1508           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
1509         {
1510           DECL_SOURCE_LOCATION (olddecl)
1511             = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
1512             = DECL_SOURCE_LOCATION (newdecl);
1513           if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1514             DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (olddecl))
1515               = DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (newdecl));
1516         }
1517
1518       if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1519         {
1520           DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl))
1521             |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl));
1522           DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl))
1523             |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl));
1524         }
1525
1526       return olddecl;
1527     }
1528
1529   if (types_match)
1530     {
1531       /* Automatically handles default parameters.  */
1532       tree oldtype = TREE_TYPE (olddecl);
1533       tree newtype;
1534
1535       /* Merge the data types specified in the two decls.  */
1536       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1537
1538       /* If merge_types produces a non-typedef type, just use the old type.  */
1539       if (TREE_CODE (newdecl) == TYPE_DECL
1540           && newtype == DECL_ORIGINAL_TYPE (newdecl))
1541         newtype = oldtype;
1542
1543       if (TREE_CODE (newdecl) == VAR_DECL)
1544         {
1545           DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1546           DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1547           DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1548             |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1549         }
1550
1551       /* Do this after calling `merge_types' so that default
1552          parameters don't confuse us.  */
1553       else if (TREE_CODE (newdecl) == FUNCTION_DECL
1554           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
1555               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
1556         {
1557           TREE_TYPE (newdecl) = build_exception_variant (newtype,
1558                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
1559           TREE_TYPE (olddecl) = build_exception_variant (newtype,
1560                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
1561
1562           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
1563               && ! DECL_IS_BUILTIN (olddecl)
1564               && flag_exceptions
1565               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
1566                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
1567             {
1568               error ("declaration of %qF throws different exceptions",
1569                      newdecl);
1570               cp_error_at ("than previous declaration %qF", olddecl);
1571             }
1572         }
1573       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1574
1575       /* Lay the type out, unless already done.  */
1576       if (! same_type_p (newtype, oldtype)
1577           && TREE_TYPE (newdecl) != error_mark_node
1578           && !(processing_template_decl && uses_template_parms (newdecl)))
1579         layout_type (TREE_TYPE (newdecl));
1580
1581       if ((TREE_CODE (newdecl) == VAR_DECL
1582            || TREE_CODE (newdecl) == PARM_DECL
1583            || TREE_CODE (newdecl) == RESULT_DECL
1584            || TREE_CODE (newdecl) == FIELD_DECL
1585            || TREE_CODE (newdecl) == TYPE_DECL)
1586           && !(processing_template_decl && uses_template_parms (newdecl)))
1587         layout_decl (newdecl, 0);
1588
1589       /* Merge the type qualifiers.  */
1590       if (TREE_READONLY (newdecl))
1591         TREE_READONLY (olddecl) = 1;
1592       if (TREE_THIS_VOLATILE (newdecl))
1593         TREE_THIS_VOLATILE (olddecl) = 1;
1594       if (TREE_NOTHROW (newdecl))
1595         TREE_NOTHROW (olddecl) = 1;
1596
1597       /* Merge deprecatedness.  */
1598       if (TREE_DEPRECATED (newdecl))
1599         TREE_DEPRECATED (olddecl) = 1;
1600
1601       /* Merge the initialization information.  */
1602       if (DECL_INITIAL (newdecl) == NULL_TREE
1603           && DECL_INITIAL (olddecl) != NULL_TREE)
1604         {
1605           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1606           DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1607           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1608               && DECL_LANG_SPECIFIC (newdecl)
1609               && DECL_LANG_SPECIFIC (olddecl))
1610             {
1611               DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1612               DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1613             }
1614         }
1615
1616       /* Merge the section attribute.
1617          We want to issue an error if the sections conflict but that must be
1618          done later in decl_attributes since we are called before attributes
1619          are assigned.  */
1620       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1621         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1622
1623       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1624         {
1625           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1626             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1627           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1628           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1629           TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1630           TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1631           DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1632           DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1633           /* Keep the old RTL.  */
1634           COPY_DECL_RTL (olddecl, newdecl);
1635         }
1636       else if (TREE_CODE (newdecl) == VAR_DECL
1637                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1638         {
1639           /* Keep the old RTL.  We cannot keep the old RTL if the old
1640              declaration was for an incomplete object and the new
1641              declaration is not since many attributes of the RTL will
1642              change.  */
1643           COPY_DECL_RTL (olddecl, newdecl);
1644         }
1645     }
1646   /* If cannot merge, then use the new type and qualifiers,
1647      and don't preserve the old rtl.  */
1648   else
1649     {
1650       /* Clean out any memory we had of the old declaration.  */
1651       tree oldstatic = value_member (olddecl, static_aggregates);
1652       if (oldstatic)
1653         TREE_VALUE (oldstatic) = error_mark_node;
1654
1655       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1656       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1657       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1658       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1659     }
1660
1661   /* Merge the storage class information.  */
1662   merge_weak (newdecl, olddecl);
1663
1664   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1665   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1666   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1667   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1668   if (! DECL_EXTERNAL (olddecl))
1669     DECL_EXTERNAL (newdecl) = 0;
1670
1671   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1672     {
1673       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1674       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1675       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1676       DECL_TEMPLATE_INSTANTIATED (newdecl)
1677         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1678       /* If the OLDDECL is an implicit instantiation, then the NEWDECL
1679          must be too.  But, it may not yet be marked as such if the
1680          caller has created NEWDECL, but has not yet figured out that
1681          it is a redeclaration.  */
1682       if (DECL_IMPLICIT_INSTANTIATION (olddecl)
1683           && !DECL_USE_TEMPLATE (newdecl))
1684         SET_DECL_IMPLICIT_INSTANTIATION (newdecl);
1685       /* Don't really know how much of the language-specific
1686          values we should copy from old to new.  */
1687       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1688       DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1689         DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1690       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1691       DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1692       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1693       DECL_INITIALIZED_IN_CLASS_P (newdecl)
1694         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1695       olddecl_friend = DECL_FRIEND_P (olddecl);
1696
1697       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
1698       if (TREE_CODE (newdecl) == FUNCTION_DECL
1699           || DECL_FUNCTION_TEMPLATE_P (newdecl))
1700         {
1701           DECL_BEFRIENDING_CLASSES (newdecl)
1702             = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1703                        DECL_BEFRIENDING_CLASSES (olddecl));
1704           /* DECL_THUNKS is only valid for virtual functions,
1705              otherwise it is a DECL_FRIEND_CONTEXT.  */
1706           if (DECL_VIRTUAL_P (newdecl))
1707             DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1708         }
1709     }
1710
1711   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1712     {
1713       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1714           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1715         {
1716           /* If newdecl is not a specialization, then it is not a
1717              template-related function at all.  And that means that we
1718              should have exited above, returning 0.  */
1719           gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1720
1721           if (TREE_USED (olddecl))
1722             /* From [temp.expl.spec]:
1723
1724                If a template, a member template or the member of a class
1725                template is explicitly specialized then that
1726                specialization shall be declared before the first use of
1727                that specialization that would cause an implicit
1728                instantiation to take place, in every translation unit in
1729                which such a use occurs.  */
1730             error ("explicit specialization of %qD after first use",
1731                       olddecl);
1732
1733           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1734
1735           /* [temp.expl.spec/14] We don't inline explicit specialization
1736              just because the primary template says so.  */
1737         }
1738       else
1739         {
1740           if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1741             DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1742
1743           DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1744
1745           /* If either decl says `inline', this fn is inline, unless
1746              its definition was passed already.  */
1747           if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1748             DECL_INLINE (olddecl) = 1;
1749           DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1750
1751           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1752             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1753         }
1754
1755       /* Preserve abstractness on cloned [cd]tors.  */
1756       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1757
1758       if (! types_match)
1759         {
1760           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1761           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1762           COPY_DECL_RTL (newdecl, olddecl);
1763         }
1764       if (! types_match || new_defines_function)
1765         {
1766           /* These need to be copied so that the names are available.
1767              Note that if the types do match, we'll preserve inline
1768              info and other bits, but if not, we won't.  */
1769           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1770           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1771         }
1772       if (new_defines_function)
1773         /* If defining a function declared with other language
1774            linkage, use the previously declared language linkage.  */
1775         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1776       else if (types_match)
1777         {
1778           /* If redeclaring a builtin function, and not a definition,
1779              it stays built in.  */
1780           if (DECL_BUILT_IN (olddecl))
1781             {
1782               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1783               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1784               /* If we're keeping the built-in definition, keep the rtl,
1785                  regardless of declaration matches.  */
1786               COPY_DECL_RTL (olddecl, newdecl);
1787             }
1788
1789           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1790           /* Don't clear out the arguments if we're redefining a function.  */
1791           if (DECL_ARGUMENTS (olddecl))
1792             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1793         }
1794     }
1795   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1796     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1797
1798   /* Now preserve various other info from the definition.  */
1799   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1800   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1801   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1802   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1803
1804   /* Warn about conflicting visibility specifications.  */
1805   if (DECL_VISIBILITY_SPECIFIED (olddecl)
1806       && DECL_VISIBILITY_SPECIFIED (newdecl)
1807       && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1808     {
1809       warning ("%J%qD: visibility attribute ignored because it",
1810                newdecl, newdecl);
1811       warning ("%Jconflicts with previous declaration here", olddecl);
1812     }
1813   /* Choose the declaration which specified visibility.  */
1814   if (DECL_VISIBILITY_SPECIFIED (olddecl))
1815     {
1816       DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1817       DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1818     }
1819
1820   /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
1821      with that from NEWDECL below.  */
1822   if (DECL_LANG_SPECIFIC (olddecl))
1823     {
1824       gcc_assert (DECL_LANG_SPECIFIC (olddecl)
1825                   != DECL_LANG_SPECIFIC (newdecl));
1826       ggc_free (DECL_LANG_SPECIFIC (olddecl));
1827     }
1828
1829   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1830     {
1831       int function_size;
1832
1833       function_size = sizeof (struct tree_decl);
1834
1835       memcpy ((char *) olddecl + sizeof (struct tree_common),
1836               (char *) newdecl + sizeof (struct tree_common),
1837               function_size - sizeof (struct tree_common));
1838
1839       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
1840         /* If newdecl is a template instantiation, it is possible that
1841            the following sequence of events has occurred:
1842
1843            o A friend function was declared in a class template.  The
1844            class template was instantiated.
1845
1846            o The instantiation of the friend declaration was
1847            recorded on the instantiation list, and is newdecl.
1848
1849            o Later, however, instantiate_class_template called pushdecl
1850            on the newdecl to perform name injection.  But, pushdecl in
1851            turn called duplicate_decls when it discovered that another
1852            declaration of a global function with the same name already
1853            existed.
1854
1855            o Here, in duplicate_decls, we decided to clobber newdecl.
1856
1857            If we're going to do that, we'd better make sure that
1858            olddecl, and not newdecl, is on the list of
1859            instantiations so that if we try to do the instantiation
1860            again we won't get the clobbered declaration.  */
1861         reregister_specialization (newdecl,
1862                                    DECL_TI_TEMPLATE (newdecl),
1863                                    olddecl);
1864     }
1865   else
1866     {
1867       memcpy ((char *) olddecl + sizeof (struct tree_common),
1868               (char *) newdecl + sizeof (struct tree_common),
1869               sizeof (struct tree_decl) - sizeof (struct tree_common)
1870               + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
1871     }
1872
1873   DECL_UID (olddecl) = olddecl_uid;
1874   if (olddecl_friend)
1875     DECL_FRIEND_P (olddecl) = 1;
1876
1877   /* NEWDECL contains the merged attribute lists.
1878      Update OLDDECL to be the same.  */
1879   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1880
1881   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1882     so that encode_section_info has a chance to look at the new decl
1883     flags and attributes.  */
1884   if (DECL_RTL_SET_P (olddecl)
1885       && (TREE_CODE (olddecl) == FUNCTION_DECL
1886           || (TREE_CODE (olddecl) == VAR_DECL
1887               && TREE_STATIC (olddecl))))
1888     make_decl_rtl (olddecl);
1889
1890   /* The NEWDECL will no longer be needed.  Because every out-of-class
1891      declaration of a member results in a call to duplicate_decls,
1892      freeing these nodes represents in a significant savings.  */
1893   ggc_free (newdecl);
1894
1895   return olddecl;
1896 }
1897 \f
1898 /* Return zero if the declaration NEWDECL is valid
1899    when the declaration OLDDECL (assumed to be for the same name)
1900    has already been seen.
1901    Otherwise return an error message format string with a %s
1902    where the identifier should go.  */
1903
1904 static const char *
1905 redeclaration_error_message (tree newdecl, tree olddecl)
1906 {
1907   if (TREE_CODE (newdecl) == TYPE_DECL)
1908     {
1909       /* Because C++ can put things into name space for free,
1910          constructs like "typedef struct foo { ... } foo"
1911          would look like an erroneous redeclaration.  */
1912       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
1913         return 0;
1914       else
1915         return "redefinition of %q#D";
1916     }
1917   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1918     {
1919       /* If this is a pure function, its olddecl will actually be
1920          the original initialization to `0' (which we force to call
1921          abort()).  Don't complain about redefinition in this case.  */
1922       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
1923           && DECL_INITIAL (olddecl) == NULL_TREE)
1924         return 0;
1925
1926       /* If both functions come from different namespaces, this is not
1927          a redeclaration - this is a conflict with a used function.  */
1928       if (DECL_NAMESPACE_SCOPE_P (olddecl)
1929           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
1930           && ! decls_match (olddecl, newdecl))
1931         return "%qD conflicts with used function";
1932
1933       /* We'll complain about linkage mismatches in
1934          warn_extern_redeclared_static.  */
1935
1936       /* Defining the same name twice is no good.  */
1937       if (DECL_INITIAL (olddecl) != NULL_TREE
1938           && DECL_INITIAL (newdecl) != NULL_TREE)
1939         {
1940           if (DECL_NAME (olddecl) == NULL_TREE)
1941             return "%q#D not declared in class";
1942           else
1943             return "redefinition of %q#D";
1944         }
1945       return 0;
1946     }
1947   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1948     {
1949       tree nt, ot;
1950
1951       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1952         {
1953           if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
1954               && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
1955             return "redefinition of %q#D";
1956           return NULL;
1957         }
1958
1959       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
1960           || (DECL_TEMPLATE_RESULT (newdecl)
1961               == DECL_TEMPLATE_RESULT (olddecl)))
1962         return NULL;
1963
1964       nt = DECL_TEMPLATE_RESULT (newdecl);
1965       if (DECL_TEMPLATE_INFO (nt))
1966         nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
1967       ot = DECL_TEMPLATE_RESULT (olddecl);
1968       if (DECL_TEMPLATE_INFO (ot))
1969         ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
1970       if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
1971         return "redefinition of %q#D";
1972
1973       return NULL;
1974     }
1975   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
1976     {
1977       /* Objects declared at top level:  */
1978       /* If at least one is a reference, it's ok.  */
1979       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
1980         return 0;
1981       /* Reject two definitions.  */
1982       return "redefinition of %q#D";
1983     }
1984   else
1985     {
1986       /* Objects declared with block scope:  */
1987       /* Reject two definitions, and reject a definition
1988          together with an external reference.  */
1989       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
1990         return "redeclaration of %q#D";
1991       return 0;
1992     }
1993 }
1994 \f
1995 /* Create a new label, named ID.  */
1996
1997 static tree
1998 make_label_decl (tree id, int local_p)
1999 {
2000   tree decl;
2001
2002   decl = build_decl (LABEL_DECL, id, void_type_node);
2003
2004   DECL_CONTEXT (decl) = current_function_decl;
2005   DECL_MODE (decl) = VOIDmode;
2006   C_DECLARED_LABEL_FLAG (decl) = local_p;
2007
2008   /* Say where one reference is to the label, for the sake of the
2009      error if it is not defined.  */
2010   DECL_SOURCE_LOCATION (decl) = input_location;
2011
2012   /* Record the fact that this identifier is bound to this label.  */
2013   SET_IDENTIFIER_LABEL_VALUE (id, decl);
2014
2015   return decl;
2016 }
2017
2018 /* Record this label on the list of used labels so that we can check
2019    at the end of the function to see whether or not the label was
2020    actually defined, and so we can check when the label is defined whether
2021    this use is valid.  */
2022
2023 static void
2024 use_label (tree decl)
2025 {
2026   if (named_label_uses == NULL
2027       || named_label_uses->names_in_scope != current_binding_level->names
2028       || named_label_uses->label_decl != decl)
2029     {
2030       struct named_label_use_list *new_ent;
2031       new_ent = GGC_NEW (struct named_label_use_list);
2032       new_ent->label_decl = decl;
2033       new_ent->names_in_scope = current_binding_level->names;
2034       new_ent->binding_level = current_binding_level;
2035       new_ent->o_goto_locus = input_location;
2036       new_ent->next = named_label_uses;
2037       named_label_uses = new_ent;
2038     }
2039 }
2040
2041 /* Look for a label named ID in the current function.  If one cannot
2042    be found, create one.  (We keep track of used, but undefined,
2043    labels, and complain about them at the end of a function.)  */
2044
2045 tree
2046 lookup_label (tree id)
2047 {
2048   tree decl;
2049   struct named_label_list *ent;
2050
2051   timevar_push (TV_NAME_LOOKUP);
2052   /* You can't use labels at global scope.  */
2053   if (current_function_decl == NULL_TREE)
2054     {
2055       error ("label %qE referenced outside of any function", id);
2056       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2057     }
2058
2059   /* See if we've already got this label.  */
2060   decl = IDENTIFIER_LABEL_VALUE (id);
2061   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2062     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2063
2064   /* Record this label on the list of labels used in this function.
2065      We do this before calling make_label_decl so that we get the
2066      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
2067   ent = GGC_CNEW (struct named_label_list);
2068   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
2069   ent->next = named_labels;
2070   named_labels = ent;
2071
2072   /* We need a new label.  */
2073   decl = make_label_decl (id, /*local_p=*/0);
2074
2075   /* Now fill in the information we didn't have before.  */
2076   ent->label_decl = decl;
2077
2078   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2079 }
2080
2081 /* Declare a local label named ID.  */
2082
2083 tree
2084 declare_local_label (tree id)
2085 {
2086   tree decl;
2087
2088   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2089      this scope we can restore the old value of
2090      IDENTIFIER_TYPE_VALUE.  */
2091   current_binding_level->shadowed_labels
2092     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2093                  current_binding_level->shadowed_labels);
2094   /* Look for the label.  */
2095   decl = make_label_decl (id, /*local_p=*/1);
2096   /* Now fill in the information we didn't have before.  */
2097   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
2098
2099   return decl;
2100 }
2101
2102 /* Returns nonzero if it is ill-formed to jump past the declaration of
2103    DECL.  Returns 2 if it's also a real problem.  */
2104
2105 static int
2106 decl_jump_unsafe (tree decl)
2107 {
2108   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
2109     return 0;
2110
2111   if (DECL_INITIAL (decl) == NULL_TREE
2112       && pod_type_p (TREE_TYPE (decl)))
2113     return 0;
2114
2115   /* This is really only important if we're crossing an initialization.
2116      The POD stuff is just pedantry; why should it matter if the class
2117      contains a field of pointer to member type?  */
2118   if (DECL_INITIAL (decl)
2119       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
2120     return 2;
2121   return 1;
2122 }
2123
2124 /* Check that a single previously seen jump to a newly defined label
2125    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2126    the jump context; NAMES are the names in scope in LEVEL at the jump
2127    context; FILE and LINE are the source position of the jump or 0.  */
2128
2129 static void
2130 check_previous_goto_1 (tree decl,
2131                        struct cp_binding_level* level,
2132                        tree names, const location_t *locus)
2133 {
2134   int identified = 0;
2135   int saw_eh = 0;
2136   struct cp_binding_level *b = current_binding_level;
2137   for (; b; b = b->level_chain)
2138     {
2139       tree new_decls = b->names;
2140       tree old_decls = (b == level ? names : NULL_TREE);
2141       for (; new_decls != old_decls;
2142            new_decls = TREE_CHAIN (new_decls))
2143         {
2144           int problem = decl_jump_unsafe (new_decls);
2145           if (! problem)
2146             continue;
2147
2148           if (! identified)
2149             {
2150               if (decl)
2151                 pedwarn ("jump to label %qD", decl);
2152               else
2153                 pedwarn ("jump to case label");
2154
2155               if (locus)
2156                 pedwarn ("%H  from here", locus);
2157               identified = 1;
2158             }
2159
2160           if (problem > 1)
2161             cp_error_at ("  crosses initialization of %q#D",
2162                          new_decls);
2163           else
2164             cp_pedwarn_at ("  enters scope of non-POD %q#D",
2165                            new_decls);
2166         }
2167
2168       if (b == level)
2169         break;
2170       if ((b->kind == sk_try || b->kind == sk_catch) && ! saw_eh)
2171         {
2172           if (! identified)
2173             {
2174               if (decl)
2175                 pedwarn ("jump to label %qD", decl);
2176               else
2177                 pedwarn ("jump to case label");
2178
2179               if (locus)
2180                 pedwarn ("%H  from here", locus);
2181               identified = 1;
2182             }
2183           if (b->kind == sk_try)
2184             error ("  enters try block");
2185           else
2186             error ("  enters catch block");
2187           saw_eh = 1;
2188         }
2189     }
2190 }
2191
2192 static void
2193 check_previous_goto (struct named_label_use_list* use)
2194 {
2195   check_previous_goto_1 (use->label_decl, use->binding_level,
2196                          use->names_in_scope, &use->o_goto_locus);
2197 }
2198
2199 static void
2200 check_switch_goto (struct cp_binding_level* level)
2201 {
2202   check_previous_goto_1 (NULL_TREE, level, level->names, NULL);
2203 }
2204
2205 /* Check that any previously seen jumps to a newly defined label DECL
2206    are OK.  Called by define_label.  */
2207
2208 static void
2209 check_previous_gotos (tree decl)
2210 {
2211   struct named_label_use_list **usep;
2212
2213   if (! TREE_USED (decl))
2214     return;
2215
2216   for (usep = &named_label_uses; *usep; )
2217     {
2218       struct named_label_use_list *use = *usep;
2219       if (use->label_decl == decl)
2220         {
2221           check_previous_goto (use);
2222           *usep = use->next;
2223         }
2224       else
2225         usep = &(use->next);
2226     }
2227 }
2228
2229 /* Check that a new jump to a label DECL is OK.  Called by
2230    finish_goto_stmt.  */
2231
2232 void
2233 check_goto (tree decl)
2234 {
2235   int identified = 0;
2236   tree bad;
2237   struct named_label_list *lab;
2238
2239   /* We can't know where a computed goto is jumping.  So we assume
2240      that it's OK.  */
2241   if (! DECL_P (decl))
2242     return;
2243
2244   /* If the label hasn't been defined yet, defer checking.  */
2245   if (! DECL_INITIAL (decl))
2246     {
2247       use_label (decl);
2248       return;
2249     }
2250
2251   for (lab = named_labels; lab; lab = lab->next)
2252     if (decl == lab->label_decl)
2253       break;
2254
2255   /* If the label is not on named_labels it's a gcc local label, so
2256      it must be in an outer scope, so jumping to it is always OK.  */
2257   if (lab == 0)
2258     return;
2259
2260   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
2261       && !identified)
2262     {
2263       cp_pedwarn_at ("jump to label %qD", decl);
2264       pedwarn ("  from here");
2265       identified = 1;
2266     }
2267
2268   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
2269     {
2270       tree b = TREE_VALUE (bad);
2271       int u = decl_jump_unsafe (b);
2272
2273       if (u > 1 && DECL_ARTIFICIAL (b))
2274         /* Can't skip init of __exception_info.  */
2275         error ("%J  enters catch block", b);
2276       else if (u > 1)
2277         cp_error_at ("  skips initialization of %q#D", b);
2278       else
2279         cp_pedwarn_at ("  enters scope of non-POD %q#D", b);
2280     }
2281
2282   if (lab->in_try_scope)
2283     error ("  enters try block");
2284   else if (lab->in_catch_scope)
2285     error ("  enters catch block");
2286 }
2287
2288 /* Define a label, specifying the location in the source file.
2289    Return the LABEL_DECL node for the label.  */
2290
2291 tree
2292 define_label (location_t location, tree name)
2293 {
2294   tree decl = lookup_label (name);
2295   struct named_label_list *ent;
2296   struct cp_binding_level *p;
2297
2298   timevar_push (TV_NAME_LOOKUP);
2299   for (ent = named_labels; ent; ent = ent->next)
2300     if (ent->label_decl == decl)
2301       break;
2302
2303   /* After labels, make any new cleanups in the function go into their
2304      own new (temporary) binding contour.  */
2305   for (p = current_binding_level;
2306        p->kind != sk_function_parms;
2307        p = p->level_chain)
2308     p->more_cleanups_ok = 0;
2309
2310   if (name == get_identifier ("wchar_t"))
2311     pedwarn ("label named wchar_t");
2312
2313   if (DECL_INITIAL (decl) != NULL_TREE)
2314     error ("duplicate label %qD", decl);
2315   else
2316     {
2317       /* Mark label as having been defined.  */
2318       DECL_INITIAL (decl) = error_mark_node;
2319       /* Say where in the source.  */
2320       DECL_SOURCE_LOCATION (decl) = location;
2321       if (ent)
2322         {
2323           ent->names_in_scope = current_binding_level->names;
2324           ent->binding_level = current_binding_level;
2325         }
2326       check_previous_gotos (decl);
2327     }
2328
2329   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2330 }
2331
2332 struct cp_switch
2333 {
2334   struct cp_binding_level *level;
2335   struct cp_switch *next;
2336   /* The SWITCH_STMT being built.  */
2337   tree switch_stmt;
2338   /* A splay-tree mapping the low element of a case range to the high
2339      element, or NULL_TREE if there is no high element.  Used to
2340      determine whether or not a new case label duplicates an old case
2341      label.  We need a tree, rather than simply a hash table, because
2342      of the GNU case range extension.  */
2343   splay_tree cases;
2344 };
2345
2346 /* A stack of the currently active switch statements.  The innermost
2347    switch statement is on the top of the stack.  There is no need to
2348    mark the stack for garbage collection because it is only active
2349    during the processing of the body of a function, and we never
2350    collect at that point.  */
2351
2352 static struct cp_switch *switch_stack;
2353
2354 /* Called right after a switch-statement condition is parsed.
2355    SWITCH_STMT is the switch statement being parsed.  */
2356
2357 void
2358 push_switch (tree switch_stmt)
2359 {
2360   struct cp_switch *p = xmalloc (sizeof (struct cp_switch));
2361   p->level = current_binding_level;
2362   p->next = switch_stack;
2363   p->switch_stmt = switch_stmt;
2364   p->cases = splay_tree_new (case_compare, NULL, NULL);
2365   switch_stack = p;
2366 }
2367
2368 void
2369 pop_switch (void)
2370 {
2371   struct cp_switch *cs = switch_stack;
2372   location_t switch_location;
2373
2374   /* Emit warnings as needed.  */
2375   if (EXPR_HAS_LOCATION (cs->switch_stmt))
2376     switch_location = EXPR_LOCATION (cs->switch_stmt);
2377   else
2378     switch_location = input_location;
2379   c_do_switch_warnings (cs->cases, switch_location,
2380                         SWITCH_STMT_TYPE (cs->switch_stmt),
2381                         SWITCH_STMT_COND (cs->switch_stmt));
2382
2383   splay_tree_delete (cs->cases);
2384   switch_stack = switch_stack->next;
2385   free (cs);
2386 }
2387
2388 /* Note that we've seen a definition of a case label, and complain if this
2389    is a bad place for one.  */
2390
2391 tree
2392 finish_case_label (tree low_value, tree high_value)
2393 {
2394   tree cond, r;
2395   struct cp_binding_level *p;
2396
2397   if (processing_template_decl)
2398     {
2399       tree label;
2400
2401       /* For templates, just add the case label; we'll do semantic
2402          analysis at instantiation-time.  */
2403       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2404       return add_stmt (build_case_label (low_value, high_value, label));
2405     }
2406
2407   /* Find the condition on which this switch statement depends.  */
2408   cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2409   if (cond && TREE_CODE (cond) == TREE_LIST)
2410     cond = TREE_VALUE (cond);
2411
2412   r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2413                         low_value, high_value);
2414
2415   check_switch_goto (switch_stack->level);
2416
2417   /* After labels, make any new cleanups in the function go into their
2418      own new (temporary) binding contour.  */
2419   for (p = current_binding_level;
2420        p->kind != sk_function_parms;
2421        p = p->level_chain)
2422     p->more_cleanups_ok = 0;
2423
2424   return r;
2425 }
2426 \f
2427 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
2428
2429 static hashval_t
2430 typename_hash (const void* k)
2431 {
2432   hashval_t hash;
2433   tree t = (tree) k;
2434
2435   hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2436           ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2437
2438   return hash;
2439 }
2440
2441 typedef struct typename_info {
2442   tree scope;
2443   tree name;
2444   tree template_id;
2445   bool enum_p;
2446   bool class_p;
2447 } typename_info;
2448
2449 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
2450
2451 static int
2452 typename_compare (const void * k1, const void * k2)
2453 {
2454   tree t1;
2455   const typename_info *t2;
2456
2457   t1 = (tree) k1;
2458   t2 = (const typename_info *) k2;
2459
2460   return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2461           && TYPE_CONTEXT (t1) == t2->scope
2462           && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2463           && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2464           && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2465 }
2466
2467 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
2468    the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2469
2470    Returns the new TYPENAME_TYPE.  */
2471
2472 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2473
2474 static tree
2475 build_typename_type (tree context, tree name, tree fullname,
2476                      enum tag_types tag_type)
2477 {
2478   tree t;
2479   tree d;
2480   typename_info ti;
2481   void **e;
2482   hashval_t hash;
2483
2484   if (typename_htab == NULL)
2485     typename_htab = htab_create_ggc (61, &typename_hash,
2486                                      &typename_compare, NULL);
2487
2488   ti.scope = FROB_CONTEXT (context);
2489   ti.name = name;
2490   ti.template_id = fullname;
2491   ti.enum_p = tag_type == enum_type;
2492   ti.class_p = (tag_type == class_type
2493                 || tag_type == record_type
2494                 || tag_type == union_type);
2495   hash =  (htab_hash_pointer (ti.scope)
2496            ^ htab_hash_pointer (ti.name));
2497
2498   /* See if we already have this type.  */
2499   e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2500   if (*e)
2501     t = (tree) *e;
2502   else
2503     {
2504       /* Build the TYPENAME_TYPE.  */
2505       t = make_aggr_type (TYPENAME_TYPE);
2506       TYPE_CONTEXT (t) = ti.scope;
2507       TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2508       TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2509       TYPENAME_IS_CLASS_P (t) = ti.class_p;
2510
2511       /* Build the corresponding TYPE_DECL.  */
2512       d = build_decl (TYPE_DECL, name, t);
2513       TYPE_NAME (TREE_TYPE (d)) = d;
2514       TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2515       DECL_CONTEXT (d) = FROB_CONTEXT (context);
2516       DECL_ARTIFICIAL (d) = 1;
2517
2518       /* Store it in the hash table.  */
2519       *e = t;
2520     }
2521
2522   return t;
2523 }
2524
2525 /* Resolve `typename CONTEXT::NAME'.  TAG_TYPE indicates the tag
2526    provided to name the type.  Returns an appropriate type, unless an
2527    error occurs, in which case error_mark_node is returned.  If we
2528    locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2529    return that, rather than the _TYPE it corresponds to, in other
2530    cases we look through the type decl.  If TF_ERROR is set, complain
2531    about errors, otherwise be quiet.  */
2532
2533 tree
2534 make_typename_type (tree context, tree name, enum tag_types tag_type,
2535                     tsubst_flags_t complain)
2536 {
2537   tree fullname;
2538
2539   if (name == error_mark_node
2540       || context == NULL_TREE
2541       || context == error_mark_node)
2542     return error_mark_node;
2543
2544   if (TYPE_P (name))
2545     {
2546       if (!(TYPE_LANG_SPECIFIC (name)
2547             && (CLASSTYPE_IS_TEMPLATE (name)
2548                 || CLASSTYPE_USE_TEMPLATE (name))))
2549         name = TYPE_IDENTIFIER (name);
2550       else
2551         /* Create a TEMPLATE_ID_EXPR for the type.  */
2552         name = build_nt (TEMPLATE_ID_EXPR,
2553                          CLASSTYPE_TI_TEMPLATE (name),
2554                          CLASSTYPE_TI_ARGS (name));
2555     }
2556   else if (TREE_CODE (name) == TYPE_DECL)
2557     name = DECL_NAME (name);
2558
2559   fullname = name;
2560
2561   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2562     {
2563       name = TREE_OPERAND (name, 0);
2564       if (TREE_CODE (name) == TEMPLATE_DECL)
2565         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2566     }
2567   if (TREE_CODE (name) == TEMPLATE_DECL)
2568     {
2569       error ("%qD used without template parameters", name);
2570       return error_mark_node;
2571     }
2572   gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2573   gcc_assert (TYPE_P (context));
2574
2575   if (!dependent_type_p (context)
2576       || currently_open_class (context))
2577     {
2578       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2579         {
2580           tree tmpl = NULL_TREE;
2581           if (IS_AGGR_TYPE (context))
2582             tmpl = lookup_field (context, name, 0, false);
2583           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2584             {
2585               if (complain & tf_error)
2586                 error ("no class template named %q#T in %q#T",
2587                        name, context);
2588               return error_mark_node;
2589             }
2590
2591           if (complain & tf_error)
2592             perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2593
2594           return lookup_template_class (tmpl,
2595                                         TREE_OPERAND (fullname, 1),
2596                                         NULL_TREE, context,
2597                                         /*entering_scope=*/0,
2598                                         tf_error | tf_warning | tf_user);
2599         }
2600       else
2601         {
2602           tree t;
2603
2604           if (!IS_AGGR_TYPE (context))
2605             {
2606               if (complain & tf_error)
2607                 error ("no type named %q#T in %q#T", name, context);
2608               return error_mark_node;
2609             }
2610
2611           t = lookup_field (context, name, 0, true);
2612           if (t)
2613             {
2614               if (TREE_CODE (t) != TYPE_DECL)
2615                 {
2616                   if (complain & tf_error)
2617                     error ("no type named %q#T in %q#T", name, context);
2618                   return error_mark_node;
2619                 }
2620
2621               if (complain & tf_error)
2622                 perform_or_defer_access_check (TYPE_BINFO (context), t);
2623
2624               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2625                 t = TREE_TYPE (t);
2626
2627               return t;
2628             }
2629         }
2630     }
2631
2632   /* If the CONTEXT is not a template type, then either the field is
2633      there now or its never going to be.  */
2634   if (!dependent_type_p (context))
2635     {
2636       if (complain & tf_error)
2637         error ("no type named %q#T in %q#T", name, context);
2638       return error_mark_node;
2639     }
2640
2641   return build_typename_type (context, name, fullname, tag_type);
2642 }
2643
2644 /* Resolve `CONTEXT::template NAME'.  Returns a TEMPLATE_DECL if the name
2645    can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
2646    in which case error_mark_node is returned.
2647
2648    If PARM_LIST is non-NULL, also make sure that the template parameter
2649    list of TEMPLATE_DECL matches.
2650
2651    If COMPLAIN zero, don't complain about any errors that occur.  */
2652
2653 tree
2654 make_unbound_class_template (tree context, tree name, tree parm_list,
2655                              tsubst_flags_t complain)
2656 {
2657   tree t;
2658   tree d;
2659
2660   if (TYPE_P (name))
2661     name = TYPE_IDENTIFIER (name);
2662   else if (DECL_P (name))
2663     name = DECL_NAME (name);
2664   gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2665
2666   if (!dependent_type_p (context)
2667       || currently_open_class (context))
2668     {
2669       tree tmpl = NULL_TREE;
2670
2671       if (IS_AGGR_TYPE (context))
2672         tmpl = lookup_field (context, name, 0, false);
2673
2674       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2675         {
2676           if (complain & tf_error)
2677             error ("no class template named %q#T in %q#T", name, context);
2678           return error_mark_node;
2679         }
2680
2681       if (parm_list
2682           && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
2683         {
2684           if (complain & tf_error)
2685             {
2686               error ("template parameters do not match template");
2687               cp_error_at ("%qD declared here", tmpl);
2688             }
2689           return error_mark_node;
2690         }
2691
2692       if (complain & tf_error)
2693         perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2694
2695       return tmpl;
2696     }
2697
2698   /* Build the UNBOUND_CLASS_TEMPLATE.  */
2699   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2700   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2701   TREE_TYPE (t) = NULL_TREE;
2702
2703   /* Build the corresponding TEMPLATE_DECL.  */
2704   d = build_decl (TEMPLATE_DECL, name, t);
2705   TYPE_NAME (TREE_TYPE (d)) = d;
2706   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2707   DECL_CONTEXT (d) = FROB_CONTEXT (context);
2708   DECL_ARTIFICIAL (d) = 1;
2709   DECL_TEMPLATE_PARMS (d) = parm_list;
2710
2711   return t;
2712 }
2713
2714 \f
2715
2716 /* Push the declarations of builtin types into the namespace.
2717    RID_INDEX is the index of the builtin type in the array
2718    RID_POINTERS.  NAME is the name used when looking up the builtin
2719    type.  TYPE is the _TYPE node for the builtin type.  */
2720
2721 void
2722 record_builtin_type (enum rid rid_index,
2723                      const char* name,
2724                      tree type)
2725 {
2726   tree rname = NULL_TREE, tname = NULL_TREE;
2727   tree tdecl = NULL_TREE;
2728
2729   if ((int) rid_index < (int) RID_MAX)
2730     rname = ridpointers[(int) rid_index];
2731   if (name)
2732     tname = get_identifier (name);
2733
2734   /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2735      eliminated.  Built-in types should not be looked up name; their
2736      names are keywords that the parser can recognize.  However, there
2737      is code in c-common.c that uses identifier_global_value to look
2738      up built-in types by name.  */
2739   if (tname)
2740     {
2741       tdecl = build_decl (TYPE_DECL, tname, type);
2742       DECL_ARTIFICIAL (tdecl) = 1;
2743       SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2744     }
2745   if (rname)
2746     {
2747       if (!tdecl)
2748         {
2749           tdecl = build_decl (TYPE_DECL, rname, type);
2750           DECL_ARTIFICIAL (tdecl) = 1;
2751         }
2752       SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2753     }
2754
2755   if (!TYPE_NAME (type))
2756     TYPE_NAME (type) = tdecl;
2757
2758   if (tdecl)
2759     debug_hooks->type_decl (tdecl, 0);
2760 }
2761
2762 /* Record one of the standard Java types.
2763  * Declare it as having the given NAME.
2764  * If SIZE > 0, it is the size of one of the integral types;
2765  * otherwise it is the negative of the size of one of the other types.  */
2766
2767 static tree
2768 record_builtin_java_type (const char* name, int size)
2769 {
2770   tree type, decl;
2771   if (size > 0)
2772     type = make_signed_type (size);
2773   else if (size > -32)
2774     { /* "__java_char" or ""__java_boolean".  */
2775       type = make_unsigned_type (-size);
2776       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2777     }
2778   else
2779     { /* "__java_float" or ""__java_double".  */
2780       type = make_node (REAL_TYPE);
2781       TYPE_PRECISION (type) = - size;
2782       layout_type (type);
2783     }
2784   record_builtin_type (RID_MAX, name, type);
2785   decl = TYPE_NAME (type);
2786
2787   /* Suppress generate debug symbol entries for these types,
2788      since for normal C++ they are just clutter.
2789      However, push_lang_context undoes this if extern "Java" is seen.  */
2790   DECL_IGNORED_P (decl) = 1;
2791
2792   TYPE_FOR_JAVA (type) = 1;
2793   return type;
2794 }
2795
2796 /* Push a type into the namespace so that the back-ends ignore it.  */
2797
2798 static void
2799 record_unknown_type (tree type, const char* name)
2800 {
2801   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
2802   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
2803   DECL_IGNORED_P (decl) = 1;
2804   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
2805   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
2806   TYPE_ALIGN (type) = 1;
2807   TYPE_USER_ALIGN (type) = 0;
2808   TYPE_MODE (type) = TYPE_MODE (void_type_node);
2809 }
2810
2811 /* An string for which we should create an IDENTIFIER_NODE at
2812    startup.  */
2813
2814 typedef struct predefined_identifier
2815 {
2816   /* The name of the identifier.  */
2817   const char *const name;
2818   /* The place where the IDENTIFIER_NODE should be stored.  */
2819   tree *const node;
2820   /* Nonzero if this is the name of a constructor or destructor.  */
2821   const int ctor_or_dtor_p;
2822 } predefined_identifier;
2823
2824 /* Create all the predefined identifiers.  */
2825
2826 static void
2827 initialize_predefined_identifiers (void)
2828 {
2829   const predefined_identifier *pid;
2830
2831   /* A table of identifiers to create at startup.  */
2832   static const predefined_identifier predefined_identifiers[] = {
2833     { "C++", &lang_name_cplusplus, 0 },
2834     { "C", &lang_name_c, 0 },
2835     { "Java", &lang_name_java, 0 },
2836     /* Some of these names have a trailing space so that it is
2837        impossible for them to conflict with names written by users.  */
2838     { "__ct ", &ctor_identifier, 1 },
2839     { "__base_ctor ", &base_ctor_identifier, 1 },
2840     { "__comp_ctor ", &complete_ctor_identifier, 1 },
2841     { "__dt ", &dtor_identifier, 1 },
2842     { "__comp_dtor ", &complete_dtor_identifier, 1 },
2843     { "__base_dtor ", &base_dtor_identifier, 1 },
2844     { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
2845     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
2846     { "nelts", &nelts_identifier, 0 },
2847     { THIS_NAME, &this_identifier, 0 },
2848     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
2849     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
2850     { "_vptr", &vptr_identifier, 0 },
2851     { "__vtt_parm", &vtt_parm_identifier, 0 },
2852     { "::", &global_scope_name, 0 },
2853     { "std", &std_identifier, 0 },
2854     { NULL, NULL, 0 }
2855   };
2856
2857   for (pid = predefined_identifiers; pid->name; ++pid)
2858     {
2859       *pid->node = get_identifier (pid->name);
2860       if (pid->ctor_or_dtor_p)
2861         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
2862     }
2863 }
2864
2865 /* Create the predefined scalar types of C,
2866    and some nodes representing standard constants (0, 1, (void *)0).
2867    Initialize the global binding level.
2868    Make definitions for built-in primitive functions.  */
2869
2870 void
2871 cxx_init_decl_processing (void)
2872 {
2873   tree void_ftype;
2874   tree void_ftype_ptr;
2875
2876   build_common_tree_nodes (flag_signed_char, false);
2877
2878   /* Create all the identifiers we need.  */
2879   initialize_predefined_identifiers ();
2880
2881   /* Create the global variables.  */
2882   push_to_top_level ();
2883
2884   current_function_decl = NULL_TREE;
2885   current_binding_level = NULL;
2886   /* Enter the global namespace.  */
2887   gcc_assert (global_namespace == NULL_TREE);
2888   global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
2889                                       void_type_node);
2890   begin_scope (sk_namespace, global_namespace);
2891
2892   current_lang_name = NULL_TREE;
2893
2894   /* Adjust various flags based on command-line settings.  */
2895   if (!flag_permissive)
2896     flag_pedantic_errors = 1;
2897   if (!flag_no_inline)
2898     {
2899       flag_inline_trees = 1;
2900       flag_no_inline = 1;
2901     }
2902   if (flag_inline_functions)
2903     flag_inline_trees = 2;
2904
2905   /* Force minimum function alignment if using the least significant
2906      bit of function pointers to store the virtual bit.  */
2907   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
2908       && force_align_functions_log < 1)
2909     force_align_functions_log = 1;
2910
2911   /* Initially, C.  */
2912   current_lang_name = lang_name_c;
2913
2914   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
2915   TREE_TYPE (error_mark_list) = error_mark_node;
2916
2917   /* Create the `std' namespace.  */
2918   push_namespace (std_identifier);
2919   std_node = current_namespace;
2920   pop_namespace ();
2921
2922   c_common_nodes_and_builtins ();
2923
2924   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
2925   java_short_type_node = record_builtin_java_type ("__java_short", 16);
2926   java_int_type_node = record_builtin_java_type ("__java_int", 32);
2927   java_long_type_node = record_builtin_java_type ("__java_long", 64);
2928   java_float_type_node = record_builtin_java_type ("__java_float", -32);
2929   java_double_type_node = record_builtin_java_type ("__java_double", -64);
2930   java_char_type_node = record_builtin_java_type ("__java_char", -16);
2931   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
2932
2933   integer_two_node = build_int_cst (NULL_TREE, 2);
2934   integer_three_node = build_int_cst (NULL_TREE, 3);
2935
2936   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
2937   truthvalue_type_node = boolean_type_node;
2938   truthvalue_false_node = boolean_false_node;
2939   truthvalue_true_node = boolean_true_node;
2940
2941   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
2942
2943 #if 0
2944   record_builtin_type (RID_MAX, NULL, string_type_node);
2945 #endif
2946
2947   delta_type_node = ptrdiff_type_node;
2948   vtable_index_type = ptrdiff_type_node;
2949
2950   vtt_parm_type = build_pointer_type (const_ptr_type_node);
2951   void_ftype = build_function_type (void_type_node, void_list_node);
2952   void_ftype_ptr = build_function_type (void_type_node,
2953                                         tree_cons (NULL_TREE,
2954                                                    ptr_type_node,
2955                                                    void_list_node));
2956   void_ftype_ptr
2957     = build_exception_variant (void_ftype_ptr, empty_except_spec);
2958
2959   /* C++ extensions */
2960
2961   unknown_type_node = make_node (UNKNOWN_TYPE);
2962   record_unknown_type (unknown_type_node, "unknown type");
2963
2964   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
2965   TREE_TYPE (unknown_type_node) = unknown_type_node;
2966
2967   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
2968      result.  */
2969   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
2970   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
2971
2972   {
2973     /* Make sure we get a unique function type, so we can give
2974        its pointer type a name.  (This wins for gdb.) */
2975     tree vfunc_type = make_node (FUNCTION_TYPE);
2976     TREE_TYPE (vfunc_type) = integer_type_node;
2977     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
2978     layout_type (vfunc_type);
2979
2980     vtable_entry_type = build_pointer_type (vfunc_type);
2981   }
2982   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
2983
2984   vtbl_type_node
2985     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
2986   layout_type (vtbl_type_node);
2987   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
2988   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
2989   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
2990   layout_type (vtbl_ptr_type_node);
2991   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
2992
2993   push_namespace (get_identifier ("__cxxabiv1"));
2994   abi_node = current_namespace;
2995   pop_namespace ();
2996
2997   global_type_node = make_node (LANG_TYPE);
2998   record_unknown_type (global_type_node, "global type");
2999
3000   /* Now, C++.  */
3001   current_lang_name = lang_name_cplusplus;
3002
3003   {
3004     tree bad_alloc_id;
3005     tree bad_alloc_type_node;
3006     tree bad_alloc_decl;
3007     tree newtype, deltype;
3008     tree ptr_ftype_sizetype;
3009
3010     push_namespace (std_identifier);
3011     bad_alloc_id = get_identifier ("bad_alloc");
3012     bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3013     TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3014     bad_alloc_decl
3015       = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3016     DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3017     TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3018     pop_namespace ();
3019
3020     ptr_ftype_sizetype
3021       = build_function_type (ptr_type_node,
3022                              tree_cons (NULL_TREE,
3023                                         size_type_node,
3024                                         void_list_node));
3025     newtype = build_exception_variant
3026       (ptr_ftype_sizetype, add_exception_specifier
3027        (NULL_TREE, bad_alloc_type_node, -1));
3028     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3029     push_cp_library_fn (NEW_EXPR, newtype);
3030     push_cp_library_fn (VEC_NEW_EXPR, newtype);
3031     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3032     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3033   }
3034
3035   abort_fndecl
3036     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3037
3038   /* Perform other language dependent initializations.  */
3039   init_class_processing ();
3040   init_rtti_processing ();
3041
3042   if (flag_exceptions)
3043     init_exception_processing ();
3044
3045   if (! supports_one_only ())
3046     flag_weak = 0;
3047
3048   make_fname_decl = cp_make_fname_decl;
3049   start_fname_decls ();
3050
3051   /* Show we use EH for cleanups.  */
3052   if (flag_exceptions)
3053     using_eh_for_cleanups ();
3054 }
3055
3056 /* Generate an initializer for a function naming variable from
3057    NAME. NAME may be NULL, to indicate a dependent name.  TYPE_P is
3058    filled in with the type of the init.  */
3059
3060 tree
3061 cp_fname_init (const char* name, tree *type_p)
3062 {
3063   tree domain = NULL_TREE;
3064   tree type;
3065   tree init = NULL_TREE;
3066   size_t length = 0;
3067
3068   if (name)
3069     {
3070       length = strlen (name);
3071       domain = build_index_type (size_int (length));
3072       init = build_string (length + 1, name);
3073     }
3074
3075   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3076   type = build_cplus_array_type (type, domain);
3077
3078   *type_p = type;
3079
3080   if (init)
3081     TREE_TYPE (init) = type;
3082   else
3083     init = error_mark_node;
3084
3085   return init;
3086 }
3087
3088 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3089    decl, NAME is the initialization string and TYPE_DEP indicates whether
3090    NAME depended on the type of the function. We make use of that to detect
3091    __PRETTY_FUNCTION__ inside a template fn. This is being done
3092    lazily at the point of first use, so we mustn't push the decl now.  */
3093
3094 static tree
3095 cp_make_fname_decl (tree id, int type_dep)
3096 {
3097   const char *const name = (type_dep && processing_template_decl
3098                             ? NULL : fname_as_string (type_dep));
3099   tree type;
3100   tree init = cp_fname_init (name, &type);
3101   tree decl = build_decl (VAR_DECL, id, type);
3102
3103   if (name)
3104     free ((char *) name);
3105
3106   /* As we're using pushdecl_with_scope, we must set the context.  */
3107   DECL_CONTEXT (decl) = current_function_decl;
3108   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3109
3110   TREE_STATIC (decl) = 1;
3111   TREE_READONLY (decl) = 1;
3112   DECL_ARTIFICIAL (decl) = 1;
3113   DECL_INITIAL (decl) = init;
3114
3115   TREE_USED (decl) = 1;
3116
3117   if (current_function_decl)
3118     {
3119       struct cp_binding_level *b = current_binding_level;
3120       while (b->level_chain->kind != sk_function_parms)
3121         b = b->level_chain;
3122       pushdecl_with_scope (decl, b);
3123       cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
3124     }
3125   else
3126     pushdecl_top_level_and_finish (decl, init);
3127
3128   return decl;
3129 }
3130
3131 /* Make a definition for a builtin function named NAME in the current
3132    namespace, whose data type is TYPE and whose context is CONTEXT.
3133    TYPE should be a function type with argument types.
3134
3135    CLASS and CODE tell later passes how to compile calls to this function.
3136    See tree.h for possible values.
3137
3138    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3139    the name to be called if we can't opencode the function.
3140    If ATTRS is nonzero, use that for the function's attribute
3141    list.  */
3142
3143 static tree
3144 builtin_function_1 (const char* name,
3145                     tree type,
3146                     tree context,
3147                     enum built_in_function code,
3148                     enum built_in_class class,
3149                     const char* libname,
3150                     tree attrs)
3151 {
3152   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3153   DECL_BUILT_IN_CLASS (decl) = class;
3154   DECL_FUNCTION_CODE (decl) = code;
3155   DECL_CONTEXT (decl) = context;
3156
3157   pushdecl (decl);
3158
3159   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3160      we cannot change DECL_ASSEMBLER_NAME until we have installed this
3161      function in the namespace.  */
3162   if (libname)
3163     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3164
3165   /* Warn if a function in the namespace for users
3166      is used without an occasion to consider it declared.  */
3167   if (name[0] != '_' || name[1] != '_')
3168     DECL_ANTICIPATED (decl) = 1;
3169
3170   /* Possibly apply some default attributes to this built-in function.  */
3171   if (attrs)
3172     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3173   else
3174     decl_attributes (&decl, NULL_TREE, 0);
3175
3176   return decl;
3177 }
3178
3179 /* Entry point for the benefit of c_common_nodes_and_builtins.
3180
3181    Make a definition for a builtin function named NAME and whose data type
3182    is TYPE.  TYPE should be a function type with argument types.  This
3183    function places the anticipated declaration in the global namespace
3184    and additionally in the std namespace if appropriate.
3185
3186    CLASS and CODE tell later passes how to compile calls to this function.
3187    See tree.h for possible values.
3188
3189    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3190    the name to be called if we can't opencode the function.
3191
3192    If ATTRS is nonzero, use that for the function's attribute
3193    list.  */
3194
3195 tree
3196 builtin_function (const char* name,
3197                   tree type,
3198                   int code,
3199                   enum built_in_class cl,
3200                   const char* libname,
3201                   tree attrs)
3202 {
3203   /* All builtins that don't begin with an '_' should additionally
3204      go in the 'std' namespace.  */
3205   if (name[0] != '_')
3206     {
3207       push_namespace (std_identifier);
3208       builtin_function_1 (name, type, std_node, code, cl, libname, attrs);
3209       pop_namespace ();
3210     }
3211
3212   return builtin_function_1 (name, type, NULL_TREE, code,
3213                              cl, libname, attrs);
3214 }
3215
3216 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3217    function.  Not called directly.  */
3218
3219 static tree
3220 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3221 {
3222   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3223   DECL_EXTERNAL (fn) = 1;
3224   TREE_PUBLIC (fn) = 1;
3225   DECL_ARTIFICIAL (fn) = 1;
3226   TREE_NOTHROW (fn) = 1;
3227   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3228   SET_DECL_LANGUAGE (fn, lang_c);
3229   /* Runtime library routines are, by definition, available in an
3230      external shared object.  */
3231   DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3232   DECL_VISIBILITY_SPECIFIED (fn) = 1;
3233   return fn;
3234 }
3235
3236 /* Returns the _DECL for a library function with C linkage.
3237    We assume that such functions never throw; if this is incorrect,
3238    callers should unset TREE_NOTHROW.  */
3239
3240 tree
3241 build_library_fn (tree name, tree type)
3242 {
3243   return build_library_fn_1 (name, ERROR_MARK, type);
3244 }
3245
3246 /* Returns the _DECL for a library function with C++ linkage.  */
3247
3248 static tree
3249 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3250 {
3251   tree fn = build_library_fn_1 (name, operator_code, type);
3252   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3253   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3254   SET_DECL_LANGUAGE (fn, lang_cplusplus);
3255   return fn;
3256 }
3257
3258 /* Like build_library_fn, but takes a C string instead of an
3259    IDENTIFIER_NODE.  */
3260
3261 tree
3262 build_library_fn_ptr (const char* name, tree type)
3263 {
3264   return build_library_fn (get_identifier (name), type);
3265 }
3266
3267 /* Like build_cp_library_fn, but takes a C string instead of an
3268    IDENTIFIER_NODE.  */
3269
3270 tree
3271 build_cp_library_fn_ptr (const char* name, tree type)
3272 {
3273   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3274 }
3275
3276 /* Like build_library_fn, but also pushes the function so that we will
3277    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
3278
3279 tree
3280 push_library_fn (tree name, tree type)
3281 {
3282   tree fn = build_library_fn (name, type);
3283   pushdecl_top_level (fn);
3284   return fn;
3285 }
3286
3287 /* Like build_cp_library_fn, but also pushes the function so that it
3288    will be found by normal lookup.  */
3289
3290 static tree
3291 push_cp_library_fn (enum tree_code operator_code, tree type)
3292 {
3293   tree fn = build_cp_library_fn (ansi_opname (operator_code),
3294                                  operator_code,
3295                                  type);
3296   pushdecl (fn);
3297   return fn;
3298 }
3299
3300 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3301    a FUNCTION_TYPE.  */
3302
3303 tree
3304 push_void_library_fn (tree name, tree parmtypes)
3305 {
3306   tree type = build_function_type (void_type_node, parmtypes);
3307   return push_library_fn (name, type);
3308 }
3309
3310 /* Like push_library_fn, but also note that this function throws
3311    and does not return.  Used for __throw_foo and the like.  */
3312
3313 tree
3314 push_throw_library_fn (tree name, tree type)
3315 {
3316   tree fn = push_library_fn (name, type);
3317   TREE_THIS_VOLATILE (fn) = 1;
3318   TREE_NOTHROW (fn) = 0;
3319   return fn;
3320 }
3321 \f
3322 /* When we call finish_struct for an anonymous union, we create
3323    default copy constructors and such.  But, an anonymous union
3324    shouldn't have such things; this function undoes the damage to the
3325    anonymous union type T.
3326
3327    (The reason that we create the synthesized methods is that we don't
3328    distinguish `union { int i; }' from `typedef union { int i; } U'.
3329    The first is an anonymous union; the second is just an ordinary
3330    union type.)  */
3331
3332 void
3333 fixup_anonymous_aggr (tree t)
3334 {
3335   tree *q;
3336
3337   /* Wipe out memory of synthesized methods.  */
3338   TYPE_HAS_CONSTRUCTOR (t) = 0;
3339   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3340   TYPE_HAS_INIT_REF (t) = 0;
3341   TYPE_HAS_CONST_INIT_REF (t) = 0;
3342   TYPE_HAS_ASSIGN_REF (t) = 0;
3343   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3344
3345   /* Splice the implicitly generated functions out of the TYPE_METHODS
3346      list.  */
3347   q = &TYPE_METHODS (t);
3348   while (*q)
3349     {
3350       if (DECL_ARTIFICIAL (*q))
3351         *q = TREE_CHAIN (*q);
3352       else
3353         q = &TREE_CHAIN (*q);
3354     }
3355
3356   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
3357   if (TYPE_METHODS (t))
3358     error ("%Jan anonymous union cannot have function members",
3359            TYPE_MAIN_DECL (t));
3360
3361   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3362      assignment operators (because they cannot have these methods themselves).
3363      For anonymous unions this is already checked because they are not allowed
3364      in any union, otherwise we have to check it.  */
3365   if (TREE_CODE (t) != UNION_TYPE)
3366     {
3367       tree field, type;
3368
3369       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3370         if (TREE_CODE (field) == FIELD_DECL)
3371           {
3372             type = TREE_TYPE (field);
3373             if (CLASS_TYPE_P (type))
3374               {
3375                 if (TYPE_NEEDS_CONSTRUCTING (type))
3376                   cp_error_at ("member %q#D with constructor not allowed "
3377                                "in anonymous aggregate",
3378                                field);
3379                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3380                   cp_error_at ("member %q#D with destructor not allowed "
3381                                "in anonymous aggregate",
3382                                field);
3383                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3384                   cp_error_at ("member %q#D with copy assignment operator "
3385                                "not allowed in anonymous aggregate",
3386                                field);
3387               }
3388           }
3389     }
3390 }
3391
3392 /* Make sure that a declaration with no declarator is well-formed, i.e.
3393    just declares a tagged type or anonymous union.
3394
3395    Returns the type declared; or NULL_TREE if none.  */
3396
3397 tree
3398 check_tag_decl (cp_decl_specifier_seq *declspecs)
3399 {
3400   int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3401   int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3402   /* If a class, struct, or enum type is declared by the DECLSPECS
3403      (i.e, if a class-specifier, enum-specifier, or non-typename
3404      elaborated-type-specifier appears in the DECLSPECS),
3405      DECLARED_TYPE is set to the corresponding type.  */
3406   tree declared_type = NULL_TREE;
3407   bool error_p = false;
3408
3409   if (declspecs->multiple_types_p)
3410     error ("multiple types in one declaration");
3411   else if (declspecs->redefined_builtin_type)
3412     {
3413       if (!in_system_header)
3414         pedwarn ("redeclaration of C++ built-in type %qT",
3415                  declspecs->redefined_builtin_type);
3416       return NULL_TREE;
3417     }
3418
3419   if (declspecs->type
3420       && TYPE_P (declspecs->type)
3421       && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3422            && IS_AGGR_TYPE (declspecs->type))
3423           || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3424     declared_type = declspecs->type;
3425   else if (declspecs->type == error_mark_node)
3426     error_p = true;
3427   if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3428     pedwarn ("declaration does not declare anything");
3429   /* Check for an anonymous union.  */
3430   else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3431            && TYPE_ANONYMOUS_P (declared_type))
3432     {
3433       /* 7/3 In a simple-declaration, the optional init-declarator-list
3434          can be omitted only when declaring a class (clause 9) or
3435          enumeration (7.2), that is, when the decl-specifier-seq contains
3436          either a class-specifier, an elaborated-type-specifier with
3437          a class-key (9.1), or an enum-specifier.  In these cases and
3438          whenever a class-specifier or enum-specifier is present in the
3439          decl-specifier-seq, the identifiers in these specifiers are among
3440          the names being declared by the declaration (as class-name,
3441          enum-names, or enumerators, depending on the syntax).  In such
3442          cases, and except for the declaration of an unnamed bit-field (9.6),
3443          the decl-specifier-seq shall introduce one or more names into the
3444          program, or shall redeclare a name introduced by a previous
3445          declaration.  [Example:
3446              enum { };            // ill-formed
3447              typedef class { };   // ill-formed
3448          --end example]  */
3449       if (saw_typedef)
3450         {
3451           error ("missing type-name in typedef-declaration");
3452           return NULL_TREE;
3453         }
3454       /* Anonymous unions are objects, so they can have specifiers.  */;
3455       SET_ANON_AGGR_TYPE_P (declared_type);
3456
3457       if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3458           && !in_system_header)
3459         pedwarn ("ISO C++ prohibits anonymous structs");
3460     }
3461
3462   else
3463     {
3464       if (declspecs->specs[(int)ds_inline]
3465           || declspecs->specs[(int)ds_virtual])
3466         error ("%qs can only be specified for functions",
3467                declspecs->specs[(int)ds_inline]
3468                ? "inline" : "virtual");
3469       else if (saw_friend
3470                && (!current_class_type
3471                    || current_scope () != current_class_type))
3472         error ("%<friend%> can only be specified inside a class");
3473       else if (declspecs->specs[(int)ds_explicit])
3474         error ("%<explicit%> can only be specified for constructors");
3475       else if (declspecs->storage_class)
3476         error ("a storage class can only be specified for objects "
3477                "and functions");
3478       else if (declspecs->specs[(int)ds_const]
3479                || declspecs->specs[(int)ds_volatile]
3480                || declspecs->specs[(int)ds_restrict]
3481                || declspecs->specs[(int)ds_thread])
3482         error ("qualifiers can only be specified for objects "
3483                "and functions");
3484     }
3485
3486   return declared_type;
3487 }
3488
3489 /* Called when a declaration is seen that contains no names to declare.
3490    If its type is a reference to a structure, union or enum inherited
3491    from a containing scope, shadow that tag name for the current scope
3492    with a forward reference.
3493    If its type defines a new named structure or union
3494    or defines an enum, it is valid but we need not do anything here.
3495    Otherwise, it is an error.
3496
3497    C++: may have to grok the declspecs to learn about static,
3498    complain for anonymous unions.
3499
3500    Returns the TYPE declared -- or NULL_TREE if none.  */
3501
3502 tree
3503 shadow_tag (cp_decl_specifier_seq *declspecs)
3504 {
3505   tree t = check_tag_decl (declspecs);
3506
3507   if (!t)
3508     return NULL_TREE;
3509
3510   if (declspecs->attributes)
3511     {
3512       cp_warning_at ("attribute ignored in declaration of %q#T", t);
3513       cp_warning_at ("attribute for %q#T must follow the %qs keyword",
3514                      t,
3515                      class_key_or_enum_as_string (t));
3516
3517     }
3518
3519   maybe_process_partial_specialization (t);
3520
3521   /* This is where the variables in an anonymous union are
3522      declared.  An anonymous union declaration looks like:
3523      union { ... } ;
3524      because there is no declarator after the union, the parser
3525      sends that declaration here.  */
3526   if (ANON_AGGR_TYPE_P (t))
3527     {
3528       fixup_anonymous_aggr (t);
3529
3530       if (TYPE_FIELDS (t))
3531         {
3532           tree decl = grokdeclarator (/*declarator=*/NULL,
3533                                       declspecs, NORMAL, 0, NULL);
3534           finish_anon_union (decl);
3535         }
3536     }
3537
3538   return t;
3539 }
3540 \f
3541 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3542
3543 tree
3544 groktypename (cp_decl_specifier_seq *type_specifiers,
3545               const cp_declarator *declarator)
3546 {
3547   tree attrs;
3548   tree type;
3549   attrs = type_specifiers->attributes;
3550   type_specifiers->attributes = NULL_TREE;
3551   type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3552   if (attrs)
3553     cplus_decl_attributes (&type, attrs, 0);
3554   return type;
3555 }
3556
3557 /* Decode a declarator in an ordinary declaration or data definition.
3558    This is called as soon as the type information and variable name
3559    have been parsed, before parsing the initializer if any.
3560    Here we create the ..._DECL node, fill in its type,
3561    and put it on the list of decls for the current context.
3562    The ..._DECL node is returned as the value.
3563
3564    Exception: for arrays where the length is not specified,
3565    the type is left null, to be filled in by `cp_finish_decl'.
3566
3567    Function definitions do not come here; they go to start_function
3568    instead.  However, external and forward declarations of functions
3569    do go through here.  Structure field declarations are done by
3570    grokfield and not through here.  */
3571
3572 tree
3573 start_decl (const cp_declarator *declarator,
3574             cp_decl_specifier_seq *declspecs,
3575             int initialized,
3576             tree attributes,
3577             tree prefix_attributes,
3578             tree *pushed_scope_p)
3579 {
3580   tree decl;
3581   tree type, tem;
3582   tree context;
3583
3584   *pushed_scope_p = NULL_TREE;
3585
3586   /* This should only be done once on the top most decl.  */
3587   if (have_extern_spec)
3588     {
3589       declspecs->storage_class = sc_extern;
3590       have_extern_spec = false;
3591     }
3592
3593   /* An object declared as __attribute__((deprecated)) suppresses
3594      warnings of uses of other deprecated items.  */
3595   if (lookup_attribute ("deprecated", attributes))
3596     deprecated_state = DEPRECATED_SUPPRESS;
3597
3598   attributes = chainon (attributes, prefix_attributes);
3599
3600   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3601                          &attributes);
3602
3603   deprecated_state = DEPRECATED_NORMAL;
3604
3605   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
3606     return error_mark_node;
3607
3608   type = TREE_TYPE (decl);
3609
3610   if (type == error_mark_node)
3611     return error_mark_node;
3612
3613   context = DECL_CONTEXT (decl);
3614
3615   if (context)
3616     {
3617       *pushed_scope_p = push_scope (context);
3618
3619       /* We are only interested in class contexts, later.  */
3620       if (TREE_CODE (context) == NAMESPACE_DECL)
3621         context = NULL_TREE;
3622     }
3623
3624   if (initialized)
3625     /* Is it valid for this decl to have an initializer at all?
3626        If not, set INITIALIZED to zero, which will indirectly
3627        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
3628     switch (TREE_CODE (decl))
3629       {
3630       case TYPE_DECL:
3631         error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3632         initialized = 0;
3633         break;
3634
3635       case FUNCTION_DECL:
3636         error ("function %q#D is initialized like a variable", decl);
3637         initialized = 0;
3638         break;
3639
3640       default:
3641         break;
3642       }
3643
3644   if (initialized)
3645     {
3646       if (! toplevel_bindings_p ()
3647           && DECL_EXTERNAL (decl))
3648         warning ("declaration of %q#D has %<extern%> and is initialized",
3649                  decl);
3650       DECL_EXTERNAL (decl) = 0;
3651       if (toplevel_bindings_p ())
3652         TREE_STATIC (decl) = 1;
3653
3654       /* Tell `pushdecl' this is an initialized decl
3655          even though we don't yet have the initializer expression.
3656          Also tell `cp_finish_decl' it may store the real initializer.  */
3657       DECL_INITIAL (decl) = error_mark_node;
3658     }
3659
3660   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3661   cplus_decl_attributes (&decl, attributes, 0);
3662
3663   /* If #pragma weak was used, mark the decl weak now.  */
3664   maybe_apply_pragma_weak (decl);
3665
3666   if (TREE_CODE (decl) == FUNCTION_DECL
3667       && DECL_DECLARED_INLINE_P (decl)
3668       && DECL_UNINLINABLE (decl)
3669       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3670     warning ("%Jinline function %qD given attribute noinline", decl, decl);
3671
3672   if (context && COMPLETE_TYPE_P (complete_type (context)))
3673     {
3674       if (TREE_CODE (decl) == VAR_DECL)
3675         {
3676           tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3677           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3678             error ("%q#D is not a static member of %q#T", decl, context);
3679           else
3680             {
3681               if (DECL_CONTEXT (field) != context)
3682                 {
3683                   if (!same_type_p (DECL_CONTEXT (field), context))
3684                     pedwarn ("ISO C++ does not permit %<%T::%D%> "
3685                              "to be defined as %<%T::%D%>",
3686                              DECL_CONTEXT (field), DECL_NAME (decl),
3687                              context, DECL_NAME (decl));
3688                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3689                 }
3690               if (processing_specialization
3691                   && template_class_depth (context) == 0
3692                   && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
3693                 error ("template header not allowed in member definition "
3694                        "of explicitly specialized class");
3695               /* Static data member are tricky; an in-class initialization
3696                  still doesn't provide a definition, so the in-class
3697                  declaration will have DECL_EXTERNAL set, but will have an
3698                  initialization.  Thus, duplicate_decls won't warn
3699                  about this situation, and so we check here.  */
3700               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
3701                 error ("duplicate initialization of %qD", decl);
3702               if (duplicate_decls (decl, field))
3703                 decl = field;
3704             }
3705         }
3706       else
3707         {
3708           tree field = check_classfn (context, decl,
3709                                       (processing_template_decl
3710                                        > template_class_depth (context))
3711                                       ? current_template_parms
3712                                       : NULL_TREE);
3713           if (field && duplicate_decls (decl, field))
3714             decl = field;
3715         }
3716
3717       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
3718       DECL_IN_AGGR_P (decl) = 0;
3719       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3720           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
3721         {
3722           /* Do not mark DECL as an explicit specialization if it was
3723              not already marked as an instantiation; a declaration
3724              should never be marked as a specialization unless we know
3725              what template is being specialized.  */
3726           if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3727             SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3728           /* [temp.expl.spec] An explicit specialization of a static data
3729              member of a template is a definition if the declaration
3730              includes an initializer; otherwise, it is a declaration.
3731
3732              We check for processing_specialization so this only applies
3733              to the new specialization syntax.  */
3734           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
3735             DECL_EXTERNAL (decl) = 1;
3736         }
3737
3738       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3739         pedwarn ("declaration of %q#D outside of class is not definition",
3740                  decl);
3741     }
3742
3743   /* Enter this declaration into the symbol table.  */
3744   tem = maybe_push_decl (decl);
3745
3746   if (processing_template_decl)
3747     tem = push_template_decl (tem);
3748   if (tem == error_mark_node)
3749     return error_mark_node;
3750
3751 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3752   /* Tell the back-end to use or not use .common as appropriate.  If we say
3753      -fconserve-space, we want this to save .data space, at the expense of
3754      wrong semantics.  If we say -fno-conserve-space, we want this to
3755      produce errors about redefs; to do this we force variables into the
3756      data segment.  */
3757   DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
3758                         || !DECL_THREAD_LOCAL (tem))
3759                        && (flag_conserve_space || ! TREE_PUBLIC (tem)));
3760 #endif
3761
3762   if (! processing_template_decl)
3763     start_decl_1 (tem);
3764
3765   return tem;
3766 }
3767
3768 void
3769 start_decl_1 (tree decl)
3770 {
3771   tree type = TREE_TYPE (decl);
3772   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
3773
3774   if (type == error_mark_node)
3775     return;
3776
3777   if (initialized)
3778     /* Is it valid for this decl to have an initializer at all?
3779        If not, set INITIALIZED to zero, which will indirectly
3780        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
3781     {
3782       /* Don't allow initializations for incomplete types except for
3783          arrays which might be completed by the initialization.  */
3784       if (COMPLETE_TYPE_P (complete_type (type)))
3785         ;                       /* A complete type is ok.  */
3786       else if (TREE_CODE (type) != ARRAY_TYPE)
3787         {
3788           error ("variable %q#D has initializer but incomplete type", decl);
3789           initialized = 0;
3790           type = TREE_TYPE (decl) = error_mark_node;
3791         }
3792       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
3793         {
3794           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3795             error ("elements of array %q#D have incomplete type", decl);
3796           /* else we already gave an error in start_decl.  */
3797           initialized = 0;
3798         }
3799     }
3800
3801   if (!initialized
3802       && TREE_CODE (decl) != TYPE_DECL
3803       && TREE_CODE (decl) != TEMPLATE_DECL
3804       && type != error_mark_node
3805       && IS_AGGR_TYPE (type)
3806       && ! DECL_EXTERNAL (decl))
3807     {
3808       if ((! processing_template_decl || ! uses_template_parms (type))
3809           && !COMPLETE_TYPE_P (complete_type (type)))
3810         {
3811           error ("aggregate %q#D has incomplete type and cannot be defined",
3812                  decl);
3813           /* Change the type so that assemble_variable will give
3814              DECL an rtl we can live with: (mem (const_int 0)).  */
3815           type = TREE_TYPE (decl) = error_mark_node;
3816         }
3817       else
3818         {
3819           /* If any base type in the hierarchy of TYPE needs a constructor,
3820              then we set initialized to 1.  This way any nodes which are
3821              created for the purposes of initializing this aggregate
3822              will live as long as it does.  This is necessary for global
3823              aggregates which do not have their initializers processed until
3824              the end of the file.  */
3825           initialized = TYPE_NEEDS_CONSTRUCTING (type);
3826         }
3827     }
3828
3829   if (! initialized)
3830     DECL_INITIAL (decl) = NULL_TREE;
3831
3832   /* Create a new scope to hold this declaration if necessary.
3833      Whether or not a new scope is necessary cannot be determined
3834      until after the type has been completed; if the type is a
3835      specialization of a class template it is not until after
3836      instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
3837      will be set correctly.  */
3838   maybe_push_cleanup_level (type);
3839 }
3840
3841 /* Handle initialization of references.  DECL, TYPE, and INIT have the
3842    same meaning as in cp_finish_decl.  *CLEANUP must be NULL on entry,
3843    but will be set to a new CLEANUP_STMT if a temporary is created
3844    that must be destroyed subsequently.
3845
3846    Returns an initializer expression to use to initialize DECL, or
3847    NULL if the initialization can be performed statically.
3848
3849    Quotes on semantics can be found in ARM 8.4.3.  */
3850
3851 static tree
3852 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
3853 {
3854   tree tmp;
3855
3856   if (init == NULL_TREE)
3857     {
3858       if ((DECL_LANG_SPECIFIC (decl) == 0
3859            || DECL_IN_AGGR_P (decl) == 0)
3860           && ! DECL_THIS_EXTERN (decl))
3861         error ("%qD declared as reference but not initialized", decl);
3862       return NULL_TREE;
3863     }
3864
3865   if (TREE_CODE (init) == CONSTRUCTOR)
3866     {
3867       error ("ISO C++ forbids use of initializer list to "
3868              "initialize reference %qD", decl);
3869       return NULL_TREE;
3870     }
3871
3872   if (TREE_CODE (init) == TREE_LIST)
3873     init = build_x_compound_expr_from_list (init, "initializer");
3874
3875   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
3876       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
3877     /* Note: default conversion is only called in very special cases.  */
3878     init = decay_conversion (init);
3879
3880   /* Convert INIT to the reference type TYPE.  This may involve the
3881      creation of a temporary, whose lifetime must be the same as that
3882      of the reference.  If so, a DECL_EXPR for the temporary will be
3883      added just after the DECL_EXPR for DECL.  That's why we don't set
3884      DECL_INITIAL for local references (instead assigning to them
3885      explicitly); we need to allow the temporary to be initialized
3886      first.  */
3887   tmp = initialize_reference (type, init, decl, cleanup);
3888
3889   if (tmp == error_mark_node)
3890     return NULL_TREE;
3891   else if (tmp == NULL_TREE)
3892     {
3893       error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
3894       return NULL_TREE;
3895     }
3896
3897   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
3898     return tmp;
3899
3900   DECL_INITIAL (decl) = tmp;
3901
3902   return NULL_TREE;
3903 }
3904
3905 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3906    array until we finish parsing the initializer.  If that's the
3907    situation we're in, update DECL accordingly.  */
3908
3909 static void
3910 maybe_deduce_size_from_array_init (tree decl, tree init)
3911 {
3912   tree type = TREE_TYPE (decl);
3913
3914   if (TREE_CODE (type) == ARRAY_TYPE
3915       && TYPE_DOMAIN (type) == NULL_TREE
3916       && TREE_CODE (decl) != TYPE_DECL)
3917     {
3918       /* do_default is really a C-ism to deal with tentative definitions.
3919          But let's leave it here to ease the eventual merge.  */
3920       int do_default = !DECL_EXTERNAL (decl);
3921       tree initializer = init ? init : DECL_INITIAL (decl);
3922       int failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
3923                                             do_default);
3924
3925       if (failure == 1)
3926         error ("initializer fails to determine size of %qD", decl);
3927
3928       if (failure == 2)
3929         {
3930           if (do_default)
3931             error ("array size missing in %qD", decl);
3932           /* If a `static' var's size isn't known, make it extern as
3933              well as static, so it does not get allocated.  If it's not
3934              `static', then don't mark it extern; finish_incomplete_decl
3935              will give it a default size and it will get allocated.  */
3936           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3937             DECL_EXTERNAL (decl) = 1;
3938         }
3939
3940       if (failure == 3)
3941         error ("zero-size array %qD", decl);
3942
3943       layout_decl (decl, 0);
3944     }
3945 }
3946
3947 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
3948    any appropriate error messages regarding the layout.  */
3949
3950 static void
3951 layout_var_decl (tree decl)
3952 {
3953   tree type = TREE_TYPE (decl);
3954
3955   /* If we haven't already layed out this declaration, do so now.
3956      Note that we must not call complete type for an external object
3957      because it's type might involve templates that we are not
3958      supposed to instantiate yet.  (And it's perfectly valid to say
3959      `extern X x' for some incomplete type `X'.)  */
3960   if (!DECL_EXTERNAL (decl))
3961     complete_type (type);
3962   if (!DECL_SIZE (decl)
3963       && TREE_TYPE (decl) != error_mark_node
3964       && (COMPLETE_TYPE_P (type)
3965           || (TREE_CODE (type) == ARRAY_TYPE
3966               && !TYPE_DOMAIN (type)
3967               && COMPLETE_TYPE_P (TREE_TYPE (type)))))
3968     layout_decl (decl, 0);
3969
3970   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
3971     {
3972       /* An automatic variable with an incomplete type: that is an error.
3973          Don't talk about array types here, since we took care of that
3974          message in grokdeclarator.  */
3975       error ("storage size of %qD isn't known", decl);
3976       TREE_TYPE (decl) = error_mark_node;
3977     }
3978 #if 0
3979   /* Keep this code around in case we later want to control debug info
3980      based on whether a type is "used".  (jason 1999-11-11) */
3981
3982   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
3983     /* Let debugger know it should output info for this type.  */
3984     note_debug_info_needed (ttype);
3985
3986   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
3987     note_debug_info_needed (DECL_CONTEXT (decl));
3988 #endif
3989
3990   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3991       && DECL_SIZE (decl) != NULL_TREE
3992       && ! TREE_CONSTANT (DECL_SIZE (decl)))
3993     {
3994       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3995         constant_expression_warning (DECL_SIZE (decl));
3996       else
3997         error ("storage size of %qD isn't constant", decl);
3998     }
3999
4000   if (TREE_STATIC (decl)
4001       && !DECL_ARTIFICIAL (decl)
4002       && current_function_decl
4003       && DECL_CONTEXT (decl) == current_function_decl)
4004     push_local_name (decl);
4005 }
4006
4007 /* If a local static variable is declared in an inline function, or if
4008    we have a weak definition, we must endeavor to create only one
4009    instance of the variable at link-time.  */
4010
4011 static void
4012 maybe_commonize_var (tree decl)
4013 {
4014   /* Static data in a function with comdat linkage also has comdat
4015      linkage.  */
4016   if (TREE_STATIC (decl)
4017       /* Don't mess with __FUNCTION__.  */
4018       && ! DECL_ARTIFICIAL (decl)
4019       && DECL_FUNCTION_SCOPE_P (decl)
4020       /* Unfortunately, import_export_decl has not always been called
4021          before the function is processed, so we cannot simply check
4022          DECL_COMDAT.  */
4023       && (DECL_COMDAT (DECL_CONTEXT (decl))
4024           || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4025                || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4026               && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4027     {
4028       if (flag_weak)
4029         {
4030           /* With weak symbols, we simply make the variable COMDAT;
4031              that will cause copies in multiple translations units to
4032              be merged.  */
4033           comdat_linkage (decl);
4034         }
4035       else
4036         {
4037           if (DECL_INITIAL (decl) == NULL_TREE
4038               || DECL_INITIAL (decl) == error_mark_node)
4039             {
4040               /* Without weak symbols, we can use COMMON to merge
4041                  uninitialized variables.  */
4042               TREE_PUBLIC (decl) = 1;
4043               DECL_COMMON (decl) = 1;
4044             }
4045           else
4046             {
4047               /* While for initialized variables, we must use internal
4048                  linkage -- which means that multiple copies will not
4049                  be merged.  */
4050               TREE_PUBLIC (decl) = 0;
4051               DECL_COMMON (decl) = 0;
4052               cp_warning_at ("sorry: semantics of inline function static "
4053                              "data %q#D are wrong (you'll wind up "
4054                              "with multiple copies)", decl);
4055               warning ("%J  you can work around this by removing "
4056                        "the initializer",
4057                        decl);
4058             }
4059         }
4060     }
4061   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4062     /* Set it up again; we might have set DECL_INITIAL since the last
4063        time.  */
4064     comdat_linkage (decl);
4065 }
4066
4067 /* Issue an error message if DECL is an uninitialized const variable.  */
4068
4069 static void
4070 check_for_uninitialized_const_var (tree decl)
4071 {
4072   tree type = TREE_TYPE (decl);
4073
4074   /* ``Unless explicitly declared extern, a const object does not have
4075      external linkage and must be initialized. ($8.4; $12.1)'' ARM
4076      7.1.6 */
4077   if (TREE_CODE (decl) == VAR_DECL
4078       && TREE_CODE (type) != REFERENCE_TYPE
4079       && CP_TYPE_CONST_P (type)
4080       && !TYPE_NEEDS_CONSTRUCTING (type)
4081       && !DECL_INITIAL (decl))
4082     error ("uninitialized const %qD", decl);
4083 }
4084
4085 /* FIELD is a FIELD_DECL or NULL.  In the former case, the value
4086    returned is the next FIELD_DECL (possibly FIELD itself) that can be
4087    initialized.  If there are no more such fields, the return value
4088    will be NULL.  */
4089
4090 static tree
4091 next_initializable_field (tree field)
4092 {
4093   while (field
4094          && (TREE_CODE (field) != FIELD_DECL
4095              || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4096              || DECL_ARTIFICIAL (field)))
4097     field = TREE_CHAIN (field);
4098
4099   return field;
4100 }
4101
4102 /* Subroutine of reshape_init. Reshape the constructor for an array. INITP
4103    is the pointer to the old constructor list (to the CONSTRUCTOR_ELTS of
4104    the CONSTRUCTOR we are processing), while NEW_INIT is the CONSTRUCTOR we
4105    are building.
4106    ELT_TYPE is the element type of the array. MAX_INDEX is an INTEGER_CST
4107    representing the size of the array minus one (the maximum index), or
4108    NULL_TREE if the array was declared without specifying the size.  */
4109
4110 static bool
4111 reshape_init_array (tree elt_type, tree max_index,
4112                     tree *initp, tree new_init)
4113 {
4114   bool sized_array_p = (max_index != NULL_TREE);
4115   unsigned HOST_WIDE_INT max_index_cst = 0;
4116   unsigned HOST_WIDE_INT index;
4117
4118   if (sized_array_p)
4119     {
4120       if (host_integerp (max_index, 1))
4121         max_index_cst = tree_low_cst (max_index, 1);
4122       /* sizetype is sign extended, not zero extended.  */
4123       else
4124         max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4125                                       1);
4126     }
4127
4128   /* Loop until there are no more initializers.  */
4129   for (index = 0;
4130        *initp && (!sized_array_p || index <= max_index_cst);
4131        ++index)
4132     {
4133       tree element_init;
4134       tree designated_index;
4135
4136       element_init = reshape_init (elt_type, initp);
4137       if (element_init == error_mark_node)
4138         return false;
4139       TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
4140       CONSTRUCTOR_ELTS (new_init) = element_init;
4141       designated_index = TREE_PURPOSE (element_init);
4142       if (designated_index)
4143         {
4144           /* Handle array designated initializers (GNU extension).  */
4145           if (TREE_CODE (designated_index) == IDENTIFIER_NODE)
4146             {
4147               error ("name %qD used in a GNU-style designated "
4148                      "initializer for an array", designated_index);
4149               TREE_PURPOSE (element_init) = NULL_TREE;
4150             }
4151           else
4152             gcc_unreachable ();
4153         }
4154     }
4155
4156   return true;
4157 }
4158
4159 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4160    brace-enclosed aggregate initializer.
4161
4162    *INITP is one of a list of initializers describing a brace-enclosed
4163    initializer for an entity of the indicated aggregate TYPE.  It may
4164    not presently match the shape of the TYPE; for example:
4165
4166      struct S { int a; int b; };
4167      struct S a[] = { 1, 2, 3, 4 };
4168
4169    Here *INITP will point to TREE_LIST of four elements, rather than a
4170    list of two elements, each itself a list of two elements.  This
4171    routine transforms INIT from the former form into the latter.  The
4172    revised initializer is returned.  */
4173
4174 static tree
4175 reshape_init (tree type, tree *initp)
4176 {
4177   tree inits;
4178   tree old_init;
4179   tree old_init_value;
4180   tree new_init;
4181   bool brace_enclosed_p;
4182   bool string_init_p;
4183
4184   old_init = *initp;
4185   old_init_value = (TREE_CODE (*initp) == TREE_LIST
4186                     ? TREE_VALUE (*initp) : old_init);
4187
4188   gcc_assert (old_init_value);
4189
4190   /* If the initializer is brace-enclosed, pull initializers from the
4191      enclosed elements.  Advance past the brace-enclosed initializer
4192      now.  */
4193   if (TREE_CODE (old_init_value) == CONSTRUCTOR
4194       && BRACE_ENCLOSED_INITIALIZER_P (old_init_value))
4195     {
4196       *initp = TREE_CHAIN (old_init);
4197       TREE_CHAIN (old_init) = NULL_TREE;
4198       inits = CONSTRUCTOR_ELTS (old_init_value);
4199       initp = &inits;
4200       brace_enclosed_p = true;
4201     }
4202   else
4203     {
4204       inits = NULL_TREE;
4205       brace_enclosed_p = false;
4206     }
4207
4208   /* A non-aggregate type is always initialized with a single
4209      initializer.  */
4210   if (!CP_AGGREGATE_TYPE_P (type))
4211       {
4212         *initp = TREE_CHAIN (old_init);
4213         TREE_CHAIN (old_init) = NULL_TREE;
4214         /* It is invalid to initialize a non-aggregate type with a
4215            brace-enclosed initializer.  */
4216         if (brace_enclosed_p)
4217           {
4218             error ("brace-enclosed initializer used to initialize %qT",
4219                    type);
4220             if (TREE_CODE (old_init) == TREE_LIST)
4221               TREE_VALUE (old_init) = error_mark_node;
4222             else
4223               old_init = error_mark_node;
4224           }
4225
4226         return old_init;
4227       }
4228
4229   /* [dcl.init.aggr]
4230
4231      All implicit type conversions (clause _conv_) are considered when
4232      initializing the aggregate member with an initializer from an
4233      initializer-list.  If the initializer can initialize a member,
4234      the member is initialized.  Otherwise, if the member is itself a
4235      non-empty subaggregate, brace elision is assumed and the
4236      initializer is considered for the initialization of the first
4237      member of the subaggregate.  */
4238   if (!brace_enclosed_p
4239       && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
4240     {
4241       *initp = TREE_CHAIN (old_init);
4242       TREE_CHAIN (old_init) = NULL_TREE;
4243       return old_init;
4244     }
4245
4246   string_init_p = false;
4247   if (TREE_CODE (old_init_value) == STRING_CST
4248       && TREE_CODE (type) == ARRAY_TYPE
4249       && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4250     {
4251       /* [dcl.init.string]
4252
4253          A char array (whether plain char, signed char, or unsigned char)
4254          can be initialized by a string-literal (optionally enclosed in
4255          braces); a wchar_t array can be initialized by a wide
4256          string-literal (optionally enclosed in braces).  */
4257       new_init = old_init;
4258       /* Move past the initializer.  */
4259       *initp = TREE_CHAIN (old_init);
4260       TREE_CHAIN (old_init) = NULL_TREE;
4261       string_init_p = true;
4262     }
4263   else
4264     {
4265       /* Build a CONSTRUCTOR to hold the contents of the aggregate.  */
4266       new_init = build_constructor (NULL_TREE, NULL_TREE);
4267
4268       if (CLASS_TYPE_P (type))
4269         {
4270           tree field;
4271
4272           field = next_initializable_field (TYPE_FIELDS (type));
4273
4274           if (!field)
4275             {
4276               /* [dcl.init.aggr]
4277
4278                  An initializer for an aggregate member that is an
4279                  empty class shall have the form of an empty
4280                  initializer-list {}.  */
4281               if (!brace_enclosed_p)
4282                 {
4283                   error ("initializer for %qT must be brace-enclosed", type);
4284                   return error_mark_node;
4285                 }
4286             }
4287           else
4288             {
4289               /* Loop through the initializable fields, gathering
4290                  initializers.  */
4291               while (*initp)
4292                 {
4293                   tree field_init;
4294
4295                   /* Handle designated initializers, as an extension.  */
4296                   if (TREE_PURPOSE (*initp))
4297                     {
4298                       if (pedantic)
4299                         pedwarn ("ISO C++ does not allow designated initializers");
4300                       field = lookup_field_1 (type, TREE_PURPOSE (*initp),
4301                                               /*want_type=*/false);
4302                       if (!field || TREE_CODE (field) != FIELD_DECL)
4303                         error ("%qT has no non-static data member named %qD",
4304                                type, TREE_PURPOSE (*initp));
4305                     }
4306                   if (!field)
4307                     break;
4308
4309                   field_init = reshape_init (TREE_TYPE (field), initp);
4310                   if (field_init == error_mark_node)
4311                     return error_mark_node;
4312                   TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
4313                   CONSTRUCTOR_ELTS (new_init) = field_init;
4314                   /* [dcl.init.aggr]
4315
4316                      When a union  is  initialized with a brace-enclosed
4317                      initializer, the braces shall only contain an
4318                      initializer for the first member of the union.  */
4319                   if (TREE_CODE (type) == UNION_TYPE)
4320                     break;
4321                   field = next_initializable_field (TREE_CHAIN (field));
4322                 }
4323             }
4324         }
4325       else if (TREE_CODE (type) == ARRAY_TYPE
4326                || TREE_CODE (type) == VECTOR_TYPE)
4327         {
4328             /* If the bound of the array is known, take no more initializers
4329               than are allowed.  */
4330             tree max_index = NULL_TREE;
4331             if (TREE_CODE (type) == ARRAY_TYPE)
4332               {
4333                 if (TYPE_DOMAIN (type))
4334                   max_index = array_type_nelts (type);
4335               }
4336             else
4337               {
4338                 /* For a vector, the representation type is a struct
4339                   containing a single member which is an array of the
4340                   appropriate size.  */
4341                 tree rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4342                 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4343                   max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS
4344                                                            (rtype)));
4345               }
4346
4347           if (!reshape_init_array (TREE_TYPE (type), max_index,
4348                                    initp, new_init))
4349             return error_mark_node;
4350         }
4351       else
4352         gcc_unreachable ();
4353
4354       /* The initializers were placed in reverse order in the
4355          CONSTRUCTOR.  */
4356       CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
4357
4358       if (TREE_CODE (old_init) == TREE_LIST)
4359         new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
4360     }
4361
4362   /* If there are more initializers than necessary, issue a
4363      diagnostic.  */
4364   if (*initp)
4365     {
4366       if (brace_enclosed_p)
4367         error ("too many initializers for %qT", type);
4368       else if (warn_missing_braces && !string_init_p)
4369         warning ("missing braces around initializer");
4370     }
4371
4372   return new_init;
4373 }
4374
4375 /* Verify INIT (the initializer for DECL), and record the
4376    initialization in DECL_INITIAL, if appropriate.  CLEANUP is as for
4377    grok_reference_init.
4378
4379    If the return value is non-NULL, it is an expression that must be
4380    evaluated dynamically to initialize DECL.  */
4381
4382 static tree
4383 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4384 {
4385   tree type = TREE_TYPE (decl);
4386   tree init_code = NULL;
4387
4388   /* If `start_decl' didn't like having an initialization, ignore it now.  */
4389   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
4390     init = NULL_TREE;
4391
4392   /* If an initializer is present, DECL_INITIAL has been
4393      error_mark_node, to indicate that an as-of-yet unevaluated
4394      initialization will occur.  From now on, DECL_INITIAL reflects
4395      the static initialization -- if any -- of DECL.  */
4396   DECL_INITIAL (decl) = NULL_TREE;
4397
4398   /* Things that are going to be initialized need to have complete
4399      type.  */
4400   TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4401
4402   if (type == error_mark_node)
4403     /* We will have already complained.  */
4404     init = NULL_TREE;
4405   else if (init && COMPLETE_TYPE_P (type)
4406            && !TREE_CONSTANT (TYPE_SIZE (type)))
4407     {
4408       error ("variable-sized object %qD may not be initialized", decl);
4409       init = NULL_TREE;
4410     }
4411   else if (TREE_CODE (type) == ARRAY_TYPE
4412            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4413     {
4414       error ("elements of array %q#D have incomplete type", decl);
4415       init = NULL_TREE;
4416     }
4417   else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4418     {
4419       error ("%qD has incomplete type", decl);
4420       TREE_TYPE (decl) = error_mark_node;
4421       init = NULL_TREE;
4422     }
4423
4424   if (TREE_CODE (decl) == CONST_DECL)
4425     {
4426       gcc_assert (TREE_CODE (decl) != REFERENCE_TYPE);
4427
4428       DECL_INITIAL (decl) = init;
4429
4430       gcc_assert (init != NULL_TREE);
4431       init = NULL_TREE;
4432     }
4433   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4434     init = grok_reference_init (decl, type, init, cleanup);
4435   else if (init)
4436     {
4437       if (TREE_CODE (init) == CONSTRUCTOR
4438           && BRACE_ENCLOSED_INITIALIZER_P (init))
4439         {
4440           /* [dcl.init] paragraph 13,
4441              If T is a scalar type, then a declaration of the form
4442              T x = { a };
4443              is equivalent to
4444              T x = a;
4445
4446              reshape_init will complain about the extra braces,
4447              and doesn't do anything useful in the case where TYPE is
4448              scalar, so just don't call it.  */
4449           if (CP_AGGREGATE_TYPE_P (type))
4450             init = reshape_init (type, &init);
4451
4452           if ((*targetm.vector_opaque_p) (type))
4453             {
4454               error ("opaque vector types cannot be initialized");
4455               init = error_mark_node;
4456             }
4457         }
4458
4459       /* If DECL has an array type without a specific bound, deduce the
4460          array size from the initializer.  */
4461       maybe_deduce_size_from_array_init (decl, init);
4462       type = TREE_TYPE (decl);
4463
4464       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4465         {
4466           if (TREE_CODE (type) == ARRAY_TYPE)
4467             goto initialize_aggr;
4468           else if (TREE_CODE (init) == CONSTRUCTOR
4469                    && BRACE_ENCLOSED_INITIALIZER_P (init))
4470             {
4471               if (TYPE_NON_AGGREGATE_CLASS (type))
4472                 {
4473                   error ("%qD must be initialized by constructor, "
4474                          "not by %<{...}%>",
4475                          decl);
4476                   init = error_mark_node;
4477                 }
4478               else
4479                 goto dont_use_constructor;
4480             }
4481           else
4482             {
4483               int saved_stmts_are_full_exprs_p;
4484
4485             initialize_aggr:
4486               saved_stmts_are_full_exprs_p = 0;
4487               if (building_stmt_tree ())
4488                 {
4489                   saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4490                   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4491                 }
4492               init = build_aggr_init (decl, init, flags);
4493               if (building_stmt_tree ())
4494                 current_stmt_tree ()->stmts_are_full_exprs_p =
4495                   saved_stmts_are_full_exprs_p;
4496               return init;
4497             }
4498         }
4499       else
4500         {
4501         dont_use_constructor:
4502           if (TREE_CODE (init) != TREE_VEC)
4503             {
4504               init_code = store_init_value (decl, init);
4505               if (pedantic && TREE_CODE (type) == ARRAY_TYPE
4506                   && DECL_INITIAL (decl)
4507                   && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
4508                   && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
4509                 warning ("array %qD initialized by parenthesized string literal %qE",
4510                          decl, DECL_INITIAL (decl));
4511               init = NULL;
4512             }
4513         }
4514     }
4515   else if (DECL_EXTERNAL (decl))
4516     ;
4517   else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4518     goto initialize_aggr;
4519   else if (IS_AGGR_TYPE (type))
4520     {
4521       tree core_type = strip_array_types (type);
4522
4523       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4524         error ("structure %qD with uninitialized const members", decl);
4525       if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4526         error ("structure %qD with uninitialized reference members", decl);
4527
4528       check_for_uninitialized_const_var (decl);
4529     }
4530   else
4531     check_for_uninitialized_const_var (decl);
4532
4533   if (init && init != error_mark_node)
4534     init_code = build2 (INIT_EXPR, type, decl, init);
4535
4536   return init_code;
4537 }
4538
4539 /* If DECL is not a local variable, give it RTL.  */
4540
4541 static void
4542 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4543 {
4544   int toplev = toplevel_bindings_p ();
4545   int defer_p;
4546
4547   /* Set the DECL_ASSEMBLER_NAME for the object.  */
4548   if (asmspec)
4549     {
4550       /* The `register' keyword, when used together with an
4551          asm-specification, indicates that the variable should be
4552          placed in a particular register.  */
4553       if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
4554         {
4555           change_decl_assembler_name (decl, get_identifier (asmspec));
4556           DECL_HARD_REGISTER (decl) = 1;
4557         }
4558       else
4559         {
4560           if (TREE_CODE (decl) == FUNCTION_DECL
4561               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4562             set_builtin_user_assembler_name (decl, asmspec);
4563           set_user_assembler_name (decl, asmspec);
4564         }
4565     }
4566
4567   /* Handle non-variables up front.  */
4568   if (TREE_CODE (decl) != VAR_DECL)
4569     {
4570       rest_of_decl_compilation (decl, toplev, at_eof);
4571       return;
4572     }
4573
4574   /* If we see a class member here, it should be a static data
4575      member.  */
4576   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4577     {
4578       gcc_assert (TREE_STATIC (decl));
4579       /* An in-class declaration of a static data member should be
4580          external; it is only a declaration, and not a definition.  */
4581       if (init == NULL_TREE)
4582         gcc_assert (DECL_EXTERNAL (decl));
4583     }
4584
4585   /* We don't create any RTL for local variables.  */
4586   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4587     return;
4588
4589   /* We defer emission of local statics until the corresponding
4590      DECL_EXPR is expanded.  */
4591   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4592
4593   /* We try to defer namespace-scope static constants so that they are
4594      not emitted into the object file unnecessarily.  */
4595   if (!DECL_VIRTUAL_P (decl)
4596       && TREE_READONLY (decl)
4597       && DECL_INITIAL (decl) != NULL_TREE
4598       && DECL_INITIAL (decl) != error_mark_node
4599       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4600       && toplev
4601       && !TREE_PUBLIC (decl))
4602     {
4603       /* Fool with the linkage of static consts according to #pragma
4604          interface.  */
4605       struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename));
4606       if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
4607         {
4608           TREE_PUBLIC (decl) = 1;
4609           DECL_EXTERNAL (decl) = finfo->interface_only;
4610         }
4611
4612       defer_p = 1;
4613     }
4614   /* Likewise for template instantiations.  */
4615   else if (DECL_LANG_SPECIFIC (decl)
4616            && DECL_IMPLICIT_INSTANTIATION (decl))
4617     defer_p = 1;
4618
4619   /* If we're not deferring, go ahead and assemble the variable.  */
4620   if (!defer_p)
4621     rest_of_decl_compilation (decl, toplev, at_eof);
4622 }
4623
4624 /* Generate code to initialize DECL (a local variable).  */
4625
4626 static void
4627 initialize_local_var (tree decl, tree init)
4628 {
4629   tree type = TREE_TYPE (decl);
4630   tree cleanup;
4631
4632   gcc_assert (TREE_CODE (decl) == VAR_DECL
4633               || TREE_CODE (decl) == RESULT_DECL);
4634   gcc_assert (!TREE_STATIC (decl));
4635
4636   if (DECL_SIZE (decl) == NULL_TREE)
4637     {
4638       /* If we used it already as memory, it must stay in memory.  */
4639       DECL_INITIAL (decl) = NULL_TREE;
4640       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4641     }
4642
4643   if (DECL_SIZE (decl) && type != error_mark_node)
4644     {
4645       int already_used;
4646
4647       /* Compute and store the initial value.  */
4648       already_used = TREE_USED (decl) || TREE_USED (type);
4649
4650       /* Perform the initialization.  */
4651       if (init)
4652         {
4653           int saved_stmts_are_full_exprs_p;
4654
4655           gcc_assert (building_stmt_tree ());
4656           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4657           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4658           finish_expr_stmt (init);
4659           current_stmt_tree ()->stmts_are_full_exprs_p =
4660             saved_stmts_are_full_exprs_p;
4661         }
4662
4663       /* Set this to 0 so we can tell whether an aggregate which was
4664          initialized was ever used.  Don't do this if it has a
4665          destructor, so we don't complain about the 'resource
4666          allocation is initialization' idiom.  Now set
4667          attribute((unused)) on types so decls of that type will be
4668          marked used. (see TREE_USED, above.)  */
4669       if (TYPE_NEEDS_CONSTRUCTING (type)
4670           && ! already_used
4671           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4672           && DECL_NAME (decl))
4673         TREE_USED (decl) = 0;
4674       else if (already_used)
4675         TREE_USED (decl) = 1;
4676     }
4677
4678   /* Generate a cleanup, if necessary.  */
4679   cleanup = cxx_maybe_build_cleanup (decl);
4680   if (DECL_SIZE (decl) && cleanup)
4681     finish_decl_cleanup (decl, cleanup);
4682 }
4683
4684 /* DECL is a VAR_DECL for a compiler-generated variable with static
4685    storage duration (like a virtual table) whose initializer is a
4686    compile-time constant.  Initialize the variable and provide it to
4687    the back end.  */
4688
4689 void
4690 initialize_artificial_var (tree decl, tree init)
4691 {
4692   DECL_INITIAL (decl) = build_constructor (NULL_TREE, init);
4693   DECL_INITIALIZED_P (decl) = 1;
4694   determine_visibility (decl);
4695   layout_var_decl (decl);
4696   maybe_commonize_var (decl);
4697   make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
4698 }
4699
4700 /* Finish processing of a declaration;
4701    install its line number and initial value.
4702    If the length of an array type is not known before,
4703    it must be determined now, from the initial value, or it is an error.
4704
4705    INIT holds the value of an initializer that should be allowed to escape
4706    the normal rules.
4707
4708    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4709    if the (init) syntax was used.  */
4710
4711 void
4712 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
4713 {
4714   tree type;
4715   tree cleanup;
4716   const char *asmspec = NULL;
4717   int was_readonly = 0;
4718   bool var_definition_p = false;
4719
4720   if (decl == error_mark_node)
4721     return;
4722   else if (! decl)
4723     {
4724       if (init)
4725         error ("assignment (not initialization) in declaration");
4726       return;
4727     }
4728
4729   gcc_assert (TREE_CODE (decl) != RESULT_DECL);
4730
4731   /* Assume no cleanup is required.  */
4732   cleanup = NULL_TREE;
4733
4734   /* If a name was specified, get the string.  */
4735   if (global_scope_p (current_binding_level))
4736     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4737   if (asmspec_tree)
4738     asmspec = TREE_STRING_POINTER (asmspec_tree);
4739
4740   if (init && TREE_CODE (init) == NAMESPACE_DECL)
4741     {
4742       error ("cannot initialize %qD to namespace %qD", decl, init);
4743       init = NULL_TREE;
4744     }
4745
4746   if (current_class_type
4747       && CP_DECL_CONTEXT (decl) == current_class_type
4748       && TYPE_BEING_DEFINED (current_class_type)
4749       && (DECL_INITIAL (decl) || init))
4750     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
4751
4752   type = TREE_TYPE (decl);
4753
4754   if (type == error_mark_node)
4755     goto finish_end;
4756
4757   if (processing_template_decl)
4758     {
4759       /* Add this declaration to the statement-tree.  */
4760       if (at_function_scope_p ())
4761         add_decl_expr (decl);
4762
4763       if (init && DECL_INITIAL (decl))
4764         DECL_INITIAL (decl) = init;
4765       if (TREE_CODE (decl) == VAR_DECL
4766           && !DECL_PRETTY_FUNCTION_P (decl)
4767           && !dependent_type_p (TREE_TYPE (decl)))
4768         maybe_deduce_size_from_array_init (decl, init);
4769
4770       goto finish_end;
4771     }
4772
4773   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
4774   gcc_assert (TREE_CODE (decl) != PARM_DECL);
4775
4776   /* Take care of TYPE_DECLs up front.  */
4777   if (TREE_CODE (decl) == TYPE_DECL)
4778     {
4779       if (type != error_mark_node
4780           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
4781         {
4782           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
4783             warning ("shadowing previous type declaration of %q#D", decl);
4784           set_identifier_type_value (DECL_NAME (decl), decl);
4785         }
4786
4787       /* If we have installed this as the canonical typedef for this
4788          type, and that type has not been defined yet, delay emitting
4789          the debug information for it, as we will emit it later.  */
4790       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
4791           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
4792         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4793
4794       rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
4795                                 at_eof);
4796       goto finish_end;
4797     }
4798
4799   /* A reference will be modified here, as it is initialized.  */
4800   if (! DECL_EXTERNAL (decl)
4801       && TREE_READONLY (decl)
4802       && TREE_CODE (type) == REFERENCE_TYPE)
4803     {
4804       was_readonly = 1;
4805       TREE_READONLY (decl) = 0;
4806     }
4807
4808   if (TREE_CODE (decl) == VAR_DECL)
4809     {
4810       /* Only PODs can have thread-local storage.  Other types may require
4811          various kinds of non-trivial initialization.  */
4812       if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
4813         error ("%qD cannot be thread-local because it has non-POD type %qT",
4814                decl, TREE_TYPE (decl));
4815       /* Convert the initializer to the type of DECL, if we have not
4816          already initialized DECL.  */
4817       if (!DECL_INITIALIZED_P (decl)
4818           /* If !DECL_EXTERNAL then DECL is being defined.  In the
4819              case of a static data member initialized inside the
4820              class-specifier, there can be an initializer even if DECL
4821              is *not* defined.  */
4822           && (!DECL_EXTERNAL (decl) || init))
4823         {
4824           init = check_initializer (decl, init, flags, &cleanup);
4825           /* Thread-local storage cannot be dynamically initialized.  */
4826           if (DECL_THREAD_LOCAL (decl) && init)
4827             {
4828               error ("%qD is thread-local and so cannot be dynamically "
4829                      "initialized", decl);
4830               init = NULL_TREE;
4831             }
4832           /* Handle:
4833
4834              [dcl.init]
4835
4836              The memory occupied by any object of static storage
4837              duration is zero-initialized at program startup before
4838              any other initialization takes place.
4839
4840              We cannot create an appropriate initializer until after
4841              the type of DECL is finalized.  If DECL_INITIAL is set,
4842              then the DECL is statically initialized, and any
4843              necessary zero-initialization has already been performed.  */
4844           if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
4845             DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
4846                                                    /*nelts=*/NULL_TREE,
4847                                                    /*static_storage_p=*/true);
4848           /* Remember that the initialization for this variable has
4849              taken place.  */
4850           DECL_INITIALIZED_P (decl) = 1;
4851           /* This declaration is the definition of this variable,
4852              unless we are initializing a static data member within
4853              the class specifier.  */
4854           if (!DECL_EXTERNAL (decl))
4855             var_definition_p = true;
4856           /* The variable is being defined, so determine its
4857              visibility.  */
4858           determine_visibility (decl);
4859         }
4860       /* If the variable has an array type, lay out the type, even if
4861          there is no initializer.  It is valid to index through the
4862          array, and we must get TYPE_ALIGN set correctly on the array
4863          type.  */
4864       else if (TREE_CODE (type) == ARRAY_TYPE)
4865         layout_type (type);
4866     }
4867
4868   /* Add this declaration to the statement-tree.  This needs to happen
4869      after the call to check_initializer so that the DECL_EXPR for a
4870      reference temp is added before the DECL_EXPR for the reference itself.  */
4871   if (at_function_scope_p ())
4872     add_decl_expr (decl);
4873
4874   if (TREE_CODE (decl) == VAR_DECL)
4875     layout_var_decl (decl);
4876
4877   /* Output the assembler code and/or RTL code for variables and functions,
4878      unless the type is an undefined structure or union.
4879      If not, it will get done when the type is completed.  */
4880   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4881     {
4882       if (TREE_CODE (decl) == VAR_DECL)
4883         maybe_commonize_var (decl);
4884
4885       make_rtl_for_nonlocal_decl (decl, init, asmspec);
4886
4887       /* Check for abstractness of the type. Notice that there is no
4888          need to strip array types here since the check for those types
4889          is already done within create_array_type_for_decl.  */
4890       if (TREE_CODE (type) == FUNCTION_TYPE
4891           || TREE_CODE (type) == METHOD_TYPE)
4892         abstract_virtuals_error (decl, TREE_TYPE (type));
4893       else
4894         abstract_virtuals_error (decl, type);
4895
4896       if (TREE_CODE (decl) == FUNCTION_DECL
4897           || TREE_TYPE (decl) == error_mark_node)
4898         /* No initialization required.  */
4899         ;
4900       else if (DECL_EXTERNAL (decl)
4901                && ! (DECL_LANG_SPECIFIC (decl)
4902                      && DECL_NOT_REALLY_EXTERN (decl)))
4903         {
4904           if (init)
4905             DECL_INITIAL (decl) = init;
4906         }
4907       else
4908         {
4909           /* A variable definition.  */
4910           if (DECL_FUNCTION_SCOPE_P (decl))
4911             {
4912               /* Initialize the local variable.  */
4913               if (processing_template_decl)
4914                 {
4915                   if (init || DECL_INITIAL (decl) == error_mark_node)
4916                     DECL_INITIAL (decl) = init;
4917                 }
4918               else if (!TREE_STATIC (decl))
4919                 initialize_local_var (decl, init);
4920             }
4921
4922           /* If a variable is defined, and then a subsequent
4923              definition with external linkage is encountered, we will
4924              get here twice for the same variable.  We want to avoid
4925              calling expand_static_init more than once.  For variables
4926              that are not static data members, we can call
4927              expand_static_init only when we actually process the
4928              initializer.  It is not legal to redeclare a static data
4929              member, so this issue does not arise in that case.  */
4930           if (var_definition_p && TREE_STATIC (decl))
4931             expand_static_init (decl, init);
4932         }
4933     }
4934
4935   /* If a CLEANUP_STMT was created to destroy a temporary bound to a
4936      reference, insert it in the statement-tree now.  */
4937   if (cleanup)
4938     push_cleanup (decl, cleanup, false);
4939
4940  finish_end:
4941
4942   if (was_readonly)
4943     TREE_READONLY (decl) = 1;
4944
4945   /* If this was marked 'used', be sure it will be output.  */
4946   if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
4947     mark_decl_referenced (decl);
4948 }
4949
4950 /* This is here for a midend callback from c-common.c.  */
4951
4952 void
4953 finish_decl (tree decl, tree init, tree asmspec_tree)
4954 {
4955   cp_finish_decl (decl, init, asmspec_tree, 0);
4956 }
4957
4958 /* Returns a declaration for a VAR_DECL as if:
4959
4960      extern "C" TYPE NAME;
4961
4962    had been seen.  Used to create compiler-generated global
4963    variables.  */
4964
4965 tree
4966 declare_global_var (tree name, tree type)
4967 {
4968   tree decl;
4969
4970   push_to_top_level ();
4971   decl = build_decl (VAR_DECL, name, type);
4972   TREE_PUBLIC (decl) = 1;
4973   DECL_EXTERNAL (decl) = 1;
4974   DECL_ARTIFICIAL (decl) = 1;
4975   /* If the user has explicitly declared this variable (perhaps
4976      because the code we are compiling is part of a low-level runtime
4977      library), then it is possible that our declaration will be merged
4978      with theirs by pushdecl.  */
4979   decl = pushdecl (decl);
4980   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
4981   pop_from_top_level ();
4982
4983   return decl;
4984 }
4985
4986 /* Returns a pointer to the `atexit' function.  Note that if
4987    FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
4988    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
4989
4990 static tree
4991 get_atexit_node (void)
4992 {
4993   tree atexit_fndecl;
4994   tree arg_types;
4995   tree fn_type;
4996   tree fn_ptr_type;
4997   const char *name;
4998
4999   if (atexit_node)
5000     return atexit_node;
5001
5002   if (flag_use_cxa_atexit)
5003     {
5004       /* The declaration for `__cxa_atexit' is:
5005
5006            int __cxa_atexit (void (*)(void *), void *, void *)
5007
5008          We build up the argument types and then then function type
5009          itself.  */
5010
5011       /* First, build the pointer-to-function type for the first
5012          argument.  */
5013       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5014       fn_type = build_function_type (void_type_node, arg_types);
5015       fn_ptr_type = build_pointer_type (fn_type);
5016       /* Then, build the rest of the argument types.  */
5017       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5018       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5019       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5020       /* And the final __cxa_atexit type.  */
5021       fn_type = build_function_type (integer_type_node, arg_types);
5022       fn_ptr_type = build_pointer_type (fn_type);
5023       name = "__cxa_atexit";
5024     }
5025   else
5026     {
5027       /* The declaration for `atexit' is:
5028
5029            int atexit (void (*)());
5030
5031          We build up the argument types and then then function type
5032          itself.  */
5033       fn_type = build_function_type (void_type_node, void_list_node);
5034       fn_ptr_type = build_pointer_type (fn_type);
5035       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5036       /* Build the final atexit type.  */
5037       fn_type = build_function_type (integer_type_node, arg_types);
5038       name = "atexit";
5039     }
5040
5041   /* Now, build the function declaration.  */
5042   push_lang_context (lang_name_c);
5043   atexit_fndecl = build_library_fn_ptr (name, fn_type);
5044   mark_used (atexit_fndecl);
5045   pop_lang_context ();
5046   atexit_node = decay_conversion (atexit_fndecl);
5047
5048   return atexit_node;
5049 }
5050
5051 /* Returns the __dso_handle VAR_DECL.  */
5052
5053 static tree
5054 get_dso_handle_node (void)
5055 {
5056   if (dso_handle_node)
5057     return dso_handle_node;
5058
5059   /* Declare the variable.  */
5060   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5061                                         ptr_type_node);
5062
5063   return dso_handle_node;
5064 }
5065
5066 /* Begin a new function with internal linkage whose job will be simply
5067    to destroy some particular variable.  */
5068
5069 static GTY(()) int start_cleanup_cnt;
5070
5071 static tree
5072 start_cleanup_fn (void)
5073 {
5074   char name[32];
5075   tree parmtypes;
5076   tree fntype;
5077   tree fndecl;
5078
5079   push_to_top_level ();
5080
5081   /* No need to mangle this.  */
5082   push_lang_context (lang_name_c);
5083
5084   /* Build the parameter-types.  */
5085   parmtypes = void_list_node;
5086   /* Functions passed to __cxa_atexit take an additional parameter.
5087      We'll just ignore it.  After we implement the new calling
5088      convention for destructors, we can eliminate the use of
5089      additional cleanup functions entirely in the -fnew-abi case.  */
5090   if (flag_use_cxa_atexit)
5091     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5092   /* Build the function type itself.  */
5093   fntype = build_function_type (void_type_node, parmtypes);
5094   /* Build the name of the function.  */
5095   sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5096   /* Build the function declaration.  */
5097   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5098   /* It's a function with internal linkage, generated by the
5099      compiler.  */
5100   TREE_PUBLIC (fndecl) = 0;
5101   DECL_ARTIFICIAL (fndecl) = 1;
5102   /* Make the function `inline' so that it is only emitted if it is
5103      actually needed.  It is unlikely that it will be inlined, since
5104      it is only called via a function pointer, but we avoid unnecessary
5105      emissions this way.  */
5106   DECL_INLINE (fndecl) = 1;
5107   DECL_DECLARED_INLINE_P (fndecl) = 1;
5108   DECL_INTERFACE_KNOWN (fndecl) = 1;
5109   /* Build the parameter.  */
5110   if (flag_use_cxa_atexit)
5111     {
5112       tree parmdecl;
5113
5114       parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5115       DECL_CONTEXT (parmdecl) = fndecl;
5116       TREE_USED (parmdecl) = 1;
5117       DECL_ARGUMENTS (fndecl) = parmdecl;
5118     }
5119
5120   pushdecl (fndecl);
5121   start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5122
5123   pop_lang_context ();
5124
5125   return current_function_decl;
5126 }
5127
5128 /* Finish the cleanup function begun by start_cleanup_fn.  */
5129
5130 static void
5131 end_cleanup_fn (void)
5132 {
5133   expand_or_defer_fn (finish_function (0));
5134
5135   pop_from_top_level ();
5136 }
5137
5138 /* Generate code to handle the destruction of DECL, an object with
5139    static storage duration.  */
5140
5141 tree
5142 register_dtor_fn (tree decl)
5143 {
5144   tree cleanup;
5145   tree compound_stmt;
5146   tree args;
5147   tree fcall;
5148
5149   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5150     return void_zero_node;
5151
5152   /* Call build_cleanup before we enter the anonymous function so that
5153      any access checks will be done relative to the current scope,
5154      rather than the scope of the anonymous function.  */
5155   build_cleanup (decl);
5156
5157   /* Now start the function.  */
5158   cleanup = start_cleanup_fn ();
5159
5160   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
5161      to the original function, rather than the anonymous one.  That
5162      will make the back-end think that nested functions are in use,
5163      which causes confusion.  */
5164
5165   push_deferring_access_checks (dk_no_check);
5166   fcall = build_cleanup (decl);
5167   pop_deferring_access_checks ();
5168
5169   /* Create the body of the anonymous function.  */
5170   compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5171   finish_expr_stmt (fcall);
5172   finish_compound_stmt (compound_stmt);
5173   end_cleanup_fn ();
5174
5175   /* Call atexit with the cleanup function.  */
5176   cxx_mark_addressable (cleanup);
5177   mark_used (cleanup);
5178   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5179   if (flag_use_cxa_atexit)
5180     {
5181       args = tree_cons (NULL_TREE,
5182                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5183                         NULL_TREE);
5184       args = tree_cons (NULL_TREE, null_pointer_node, args);
5185       args = tree_cons (NULL_TREE, cleanup, args);
5186     }
5187   else
5188     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5189   return build_function_call (get_atexit_node (), args);
5190 }
5191
5192 /* DECL is a VAR_DECL with static storage duration.  INIT, if present,
5193    is its initializer.  Generate code to handle the construction
5194    and destruction of DECL.  */
5195
5196 static void
5197 expand_static_init (tree decl, tree init)
5198 {
5199   gcc_assert (TREE_CODE (decl) == VAR_DECL);
5200   gcc_assert (TREE_STATIC (decl));
5201
5202   /* Some variables require no initialization.  */
5203   if (!init
5204       && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5205       && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5206     return;
5207
5208   if (DECL_FUNCTION_SCOPE_P (decl))
5209     {
5210       /* Emit code to perform this initialization but once.  */
5211       tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
5212       tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
5213       tree guard, guard_addr, guard_addr_list;
5214       tree acquire_fn, release_fn, abort_fn;
5215       tree flag, begin;
5216
5217       /* Emit code to perform this initialization but once.  This code
5218          looks like:
5219
5220            static <type> guard;
5221            if (!guard.first_byte) {
5222              if (__cxa_guard_acquire (&guard)) {
5223                bool flag = false;
5224                try {
5225                  // Do initialization.
5226                  flag = true; __cxa_guard_release (&guard);
5227                  // Register variable for destruction at end of program.
5228                } catch {
5229                  if (!flag) __cxa_guard_abort (&guard);
5230                }
5231            }
5232
5233          Note that the `flag' variable is only set to 1 *after* the
5234          initialization is complete.  This ensures that an exception,
5235          thrown during the construction, will cause the variable to
5236          reinitialized when we pass through this code again, as per:
5237
5238            [stmt.dcl]
5239
5240            If the initialization exits by throwing an exception, the
5241            initialization is not complete, so it will be tried again
5242            the next time control enters the declaration.
5243
5244          This process should be thread-safe, too; multiple threads
5245          should not be able to initialize the variable more than
5246          once.  */
5247
5248       /* Create the guard variable.  */
5249       guard = get_guard (decl);
5250
5251       /* This optimization isn't safe on targets with relaxed memory
5252          consistency.  On such targets we force synchronization in
5253          __cxa_guard_acquire.  */
5254       if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5255         {
5256           /* Begin the conditional initialization.  */
5257           if_stmt = begin_if_stmt ();
5258           finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5259           then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5260         }
5261
5262       if (flag_threadsafe_statics)
5263         {
5264           guard_addr = build_address (guard);
5265           guard_addr_list = build_tree_list (NULL_TREE, guard_addr);
5266
5267           acquire_fn = get_identifier ("__cxa_guard_acquire");
5268           release_fn = get_identifier ("__cxa_guard_release");
5269           abort_fn = get_identifier ("__cxa_guard_abort");
5270           if (!get_global_value_if_present (acquire_fn, &acquire_fn))
5271             {
5272               tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
5273                                          void_list_node);
5274               tree vfntype = build_function_type (void_type_node, argtypes);
5275               acquire_fn = push_library_fn
5276                 (acquire_fn, build_function_type (integer_type_node, argtypes));
5277               release_fn = push_library_fn (release_fn, vfntype);
5278               abort_fn = push_library_fn (abort_fn, vfntype);
5279             }
5280           else
5281             {
5282               release_fn = identifier_global_value (release_fn);
5283               abort_fn = identifier_global_value (abort_fn);
5284             }
5285
5286           inner_if_stmt = begin_if_stmt ();
5287           finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list),
5288                                inner_if_stmt);
5289
5290           inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5291           begin = get_target_expr (boolean_false_node);
5292           flag = TARGET_EXPR_SLOT (begin);
5293
5294           TARGET_EXPR_CLEANUP (begin)
5295             = build (COND_EXPR, void_type_node, flag,
5296                      void_zero_node,
5297                      build_call (abort_fn, guard_addr_list));
5298           CLEANUP_EH_ONLY (begin) = 1;
5299
5300           /* Do the initialization itself.  */
5301           init = add_stmt_to_compound (begin, init);
5302           init = add_stmt_to_compound
5303             (init, build (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
5304           init = add_stmt_to_compound
5305             (init, build_call (release_fn, guard_addr_list));
5306         }
5307       else
5308         init = add_stmt_to_compound (init, set_guard (guard));
5309
5310       /* Use atexit to register a function for destroying this static
5311          variable.  */
5312       init = add_stmt_to_compound (init, register_dtor_fn (decl));
5313
5314       finish_expr_stmt (init);
5315
5316       if (flag_threadsafe_statics)
5317         {
5318           finish_compound_stmt (inner_then_clause);
5319           finish_then_clause (inner_if_stmt);
5320           finish_if_stmt (inner_if_stmt);
5321         }
5322
5323       if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5324         {
5325           finish_compound_stmt (then_clause);
5326           finish_then_clause (if_stmt);
5327           finish_if_stmt (if_stmt);
5328         }
5329     }
5330   else
5331     static_aggregates = tree_cons (init, decl, static_aggregates);
5332 }
5333
5334 \f
5335 /* Make TYPE a complete type based on INITIAL_VALUE.
5336    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5337    2 if there was no information (in which case assume 0 if DO_DEFAULT),
5338    3 if the initializer list is empty (in pedantic mode). */
5339
5340 int
5341 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
5342 {
5343   int failure;
5344   tree type, elt_type;
5345
5346   if (initial_value)
5347     {
5348       /* An array of character type can be initialized from a
5349          brace-enclosed string constant.  */
5350       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
5351           && TREE_CODE (initial_value) == CONSTRUCTOR
5352           && CONSTRUCTOR_ELTS (initial_value)
5353           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
5354               == STRING_CST)
5355           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
5356         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
5357     }
5358
5359   failure = complete_array_type (ptype, initial_value, do_default);
5360
5361   /* We can create the array before the element type is complete, which
5362      means that we didn't have these two bits set in the original type
5363      either.  In completing the type, we are expected to propagate these
5364      bits.  See also complete_type which does the same thing for arrays
5365      of fixed size.  */
5366   type = *ptype;
5367   if (TYPE_DOMAIN (type))
5368     {
5369       elt_type = TREE_TYPE (type);
5370       TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
5371       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5372         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
5373     }
5374
5375   return failure;
5376 }
5377 \f
5378 /* Return zero if something is declared to be a member of type
5379    CTYPE when in the context of CUR_TYPE.  STRING is the error
5380    message to print in that case.  Otherwise, quietly return 1.  */
5381
5382 static int
5383 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5384 {
5385   if (ctype && ctype != cur_type)
5386     {
5387       if (flags == DTOR_FLAG)
5388         error ("destructor for alien class %qT cannot be a member", ctype);
5389       else
5390         error ("constructor for alien class %qT cannot be a member", ctype);
5391       return 0;
5392     }
5393   return 1;
5394 }
5395 \f
5396 /* Subroutine of `grokdeclarator'.  */
5397
5398 /* Generate errors possibly applicable for a given set of specifiers.
5399    This is for ARM $7.1.2.  */
5400
5401 static void
5402 bad_specifiers (tree object,
5403                 const char* type,
5404                 int virtualp,
5405                 int quals,
5406                 int inlinep,
5407                 int friendp,
5408                 int raises)
5409 {
5410   if (virtualp)
5411     error ("%qD declared as a %<virtual%> %s", object, type);
5412   if (inlinep)
5413     error ("%qD declared as an %<inline%> %s", object, type);
5414   if (quals)
5415     error ("%<const%> and %<volatile%> function specifiers on "
5416            "%qD invalid in %s declaration",
5417            object, type);
5418   if (friendp)
5419     cp_error_at ("%qD declared as a friend", object);
5420   if (raises
5421       && (TREE_CODE (object) == TYPE_DECL
5422           || (!TYPE_PTRFN_P (TREE_TYPE (object))
5423               && !TYPE_REFFN_P (TREE_TYPE (object))
5424               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5425     cp_error_at ("%qD declared with an exception specification", object);
5426 }
5427
5428 /* CTYPE is class type, or null if non-class.
5429    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5430    or METHOD_TYPE.
5431    DECLARATOR is the function's name.
5432    PARMS is a chain of PARM_DECLs for the function.
5433    VIRTUALP is truthvalue of whether the function is virtual or not.
5434    FLAGS are to be passed through to `grokclassfn'.
5435    QUALS are qualifiers indicating whether the function is `const'
5436    or `volatile'.
5437    RAISES is a list of exceptions that this function can raise.
5438    CHECK is 1 if we must find this method in CTYPE, 0 if we should
5439    not look, and -1 if we should not call `grokclassfn' at all.
5440
5441    SFK is the kind of special function (if any) for the new function.
5442
5443    Returns `NULL_TREE' if something goes wrong, after issuing
5444    applicable error messages.  */
5445
5446 static tree
5447 grokfndecl (tree ctype,
5448             tree type,
5449             tree declarator,
5450             tree parms,
5451             tree orig_declarator,
5452             int virtualp,
5453             enum overload_flags flags,
5454             cp_cv_quals quals,
5455             tree raises,
5456             int check,
5457             int friendp,
5458             int publicp,
5459             int inlinep,
5460             special_function_kind sfk,
5461             int funcdef_flag,
5462             int template_count,
5463             tree in_namespace,
5464             tree* attrlist)
5465 {
5466   tree decl;
5467   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5468   int has_default_arg = 0;
5469   tree t;
5470
5471   if (raises)
5472     type = build_exception_variant (type, raises);
5473
5474   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5475   DECL_ARGUMENTS (decl) = parms;
5476   /* Propagate volatile out from type to decl.  */
5477   if (TYPE_VOLATILE (type))
5478     TREE_THIS_VOLATILE (decl) = 1;
5479
5480   /* If this decl has namespace scope, set that up.  */
5481   if (in_namespace)
5482     set_decl_namespace (decl, in_namespace, friendp);
5483   else if (!ctype)
5484     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5485
5486   /* `main' and builtins have implicit 'C' linkage.  */
5487   if ((MAIN_NAME_P (declarator)
5488        || (IDENTIFIER_LENGTH (declarator) > 10
5489            && IDENTIFIER_POINTER (declarator)[0] == '_'
5490            && IDENTIFIER_POINTER (declarator)[1] == '_'
5491            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
5492       && current_lang_name == lang_name_cplusplus
5493       && ctype == NULL_TREE
5494       /* NULL_TREE means global namespace.  */
5495       && DECL_CONTEXT (decl) == NULL_TREE)
5496     SET_DECL_LANGUAGE (decl, lang_c);
5497
5498   /* Should probably propagate const out from type to decl I bet (mrs).  */
5499   if (staticp)
5500     {
5501       DECL_STATIC_FUNCTION_P (decl) = 1;
5502       DECL_CONTEXT (decl) = ctype;
5503     }
5504
5505   if (ctype)
5506     DECL_CONTEXT (decl) = ctype;
5507
5508   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
5509     {
5510       if (processing_template_decl)
5511         error ("cannot declare %<::main%> to be a template");
5512       if (inlinep)
5513         error ("cannot declare %<::main%> to be inline");
5514       if (!publicp)
5515         error ("cannot declare %<::main%> to be static");
5516       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
5517                         integer_type_node))
5518         {
5519           error ("%<::main%> must return %<int%>");
5520           TREE_TYPE (TREE_TYPE (decl)) = integer_type_node;
5521         }
5522       inlinep = 0;
5523       publicp = 1;
5524     }
5525
5526   /* Members of anonymous types and local classes have no linkage; make
5527      them internal.  If a typedef is made later, this will be changed.  */
5528   if (ctype && (TYPE_ANONYMOUS_P (ctype)
5529                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
5530     publicp = 0;
5531
5532   if (publicp)
5533     {
5534       /* [basic.link]: A name with no linkage (notably, the name of a class
5535          or enumeration declared in a local scope) shall not be used to
5536          declare an entity with linkage.
5537
5538          Only check this for public decls for now.  See core 319, 389.  */
5539       t = no_linkage_check (TREE_TYPE (decl),
5540                             /*relaxed_p=*/false);
5541       if (t)
5542         {
5543           if (TYPE_ANONYMOUS_P (t))
5544             {
5545               if (DECL_EXTERN_C_P (decl))
5546                 /* Allow this; it's pretty common in C.  */;
5547               else
5548                 {
5549                   pedwarn ("non-local function %q#D uses anonymous type",
5550                               decl);
5551                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5552                     cp_pedwarn_at ("%q#D does not refer to the unqualified "
5553                                    "type, so it is not used for linkage",
5554                                    TYPE_NAME (t));
5555                 }
5556             }
5557           else
5558             pedwarn ("non-local function %q#D uses local type %qT", decl, t);
5559         }
5560     }
5561
5562   TREE_PUBLIC (decl) = publicp;
5563   if (! publicp)
5564     {
5565       DECL_INTERFACE_KNOWN (decl) = 1;
5566       DECL_NOT_REALLY_EXTERN (decl) = 1;
5567     }
5568
5569   /* If the declaration was declared inline, mark it as such.  */
5570   if (inlinep)
5571     DECL_DECLARED_INLINE_P (decl) = 1;
5572   /* We inline functions that are explicitly declared inline, or, when
5573      the user explicitly asks us to, all functions.  */
5574   if (DECL_DECLARED_INLINE_P (decl)
5575       || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
5576     DECL_INLINE (decl) = 1;
5577
5578   DECL_EXTERNAL (decl) = 1;
5579   if (quals && TREE_CODE (type) == FUNCTION_TYPE)
5580     {
5581       error ("%smember function %qD cannot have cv-qualifier",
5582              (ctype ? "static " : "non-"), decl);
5583       quals = TYPE_UNQUALIFIED;
5584     }
5585
5586   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
5587     grok_op_properties (decl, friendp, /*complain=*/true);
5588
5589   if (ctype && decl_function_context (decl))
5590     DECL_NO_STATIC_CHAIN (decl) = 1;
5591
5592   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5593     if (TREE_PURPOSE (t)
5594         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5595       {
5596         has_default_arg = 1;
5597         break;
5598       }
5599
5600   if (friendp
5601       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5602     {
5603       if (funcdef_flag)
5604         error
5605           ("defining explicit specialization %qD in friend declaration",
5606            orig_declarator);
5607       else
5608         {
5609           tree fns = TREE_OPERAND (orig_declarator, 0);
5610           tree args = TREE_OPERAND (orig_declarator, 1);
5611
5612           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5613             {
5614               /* Something like `template <class T> friend void f<T>()'.  */
5615               error ("invalid use of template-id %qD in declaration "
5616                      "of primary template",
5617                      orig_declarator);
5618               return NULL_TREE;
5619             }
5620
5621
5622           /* A friend declaration of the form friend void f<>().  Record
5623              the information in the TEMPLATE_ID_EXPR.  */
5624           SET_DECL_IMPLICIT_INSTANTIATION (decl);
5625
5626           if (TREE_CODE (fns) == COMPONENT_REF)
5627             {
5628               /* Due to bison parser ickiness, we will have already looked
5629                  up an operator_name or PFUNCNAME within the current class
5630                  (see template_id in parse.y). If the current class contains
5631                  such a name, we'll get a COMPONENT_REF here. Undo that.  */
5632
5633               gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5634                           == current_class_type);
5635               fns = TREE_OPERAND (fns, 1);
5636             }
5637           gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5638                       || TREE_CODE (fns) == OVERLOAD);
5639           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5640
5641           if (has_default_arg)
5642             {
5643               error ("default arguments are not allowed in declaration "
5644                      "of friend template specialization %qD",
5645                      decl);
5646               return NULL_TREE;
5647             }
5648
5649           if (inlinep)
5650             {
5651               error ("%<inline%> is not allowed in declaration of friend "
5652                      "template specialization %qD",
5653                      decl);
5654               return NULL_TREE;
5655             }
5656         }
5657     }
5658
5659   if (funcdef_flag)
5660     /* Make the init_value nonzero so pushdecl knows this is not
5661        tentative.  error_mark_node is replaced later with the BLOCK.  */
5662     DECL_INITIAL (decl) = error_mark_node;
5663
5664   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
5665     TREE_NOTHROW (decl) = 1;
5666
5667   /* Caller will do the rest of this.  */
5668   if (check < 0)
5669     return decl;
5670
5671   if (ctype != NULL_TREE)
5672     {
5673       if (sfk == sfk_constructor)
5674         DECL_CONSTRUCTOR_P (decl) = 1;
5675
5676       grokclassfn (ctype, decl, flags, quals);
5677     }
5678
5679   decl = check_explicit_specialization (orig_declarator, decl,
5680                                         template_count,
5681                                         2 * (funcdef_flag != 0) +
5682                                         4 * (friendp != 0));
5683   if (decl == error_mark_node)
5684     return NULL_TREE;
5685
5686   if (attrlist)
5687     {
5688       cplus_decl_attributes (&decl, *attrlist, 0);
5689       *attrlist = NULL_TREE;
5690     }
5691
5692   if (ctype != NULL_TREE
5693       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
5694       && check)
5695     {
5696       tree old_decl;
5697
5698       old_decl = check_classfn (ctype, decl,
5699                                 (processing_template_decl
5700                                  > template_class_depth (ctype))
5701                                 ? current_template_parms
5702                                 : NULL_TREE);
5703
5704       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
5705         /* Because grokfndecl is always supposed to return a
5706            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
5707            here.  We depend on our callers to figure out that its
5708            really a template that's being returned.  */
5709         old_decl = DECL_TEMPLATE_RESULT (old_decl);
5710
5711       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
5712           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
5713         /* Remove the `this' parm added by grokclassfn.
5714            XXX Isn't this done in start_function, too?  */
5715         revert_static_member_fn (decl);
5716       if (old_decl && DECL_ARTIFICIAL (old_decl))
5717         error ("definition of implicitly-declared %qD", old_decl);
5718
5719       if (old_decl)
5720         {
5721           tree ok;
5722           tree pushed_scope;
5723
5724           /* Since we've smashed OLD_DECL to its
5725              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
5726           if (TREE_CODE (decl) == TEMPLATE_DECL)
5727             decl = DECL_TEMPLATE_RESULT (decl);
5728
5729           /* Attempt to merge the declarations.  This can fail, in
5730              the case of some invalid specialization declarations.  */
5731           pushed_scope = push_scope (ctype);
5732           ok = duplicate_decls (decl, old_decl);
5733           if (pushed_scope)
5734             pop_scope (pushed_scope);
5735           if (!ok)
5736             {
5737               error ("no %q#D member function declared in class %qT",
5738                      decl, ctype);
5739               return NULL_TREE;
5740             }
5741           return old_decl;
5742         }
5743     }
5744
5745   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
5746     return NULL_TREE;
5747
5748   if (ctype == NULL_TREE || check)
5749     return decl;
5750
5751   if (virtualp)
5752     DECL_VIRTUAL_P (decl) = 1;
5753
5754   return decl;
5755 }
5756
5757 /* DECL is a VAR_DECL for a static data member.  Set flags to reflect
5758    the linkage that DECL will receive in the object file.  */
5759
5760 static void
5761 set_linkage_for_static_data_member (tree decl)
5762 {
5763   /* A static data member always has static storage duration and
5764      external linkage.  Note that static data members are forbidden in
5765      local classes -- the only situation in which a class has
5766      non-external linkage.  */
5767   TREE_PUBLIC (decl) = 1;
5768   TREE_STATIC (decl) = 1;
5769   /* For non-template classes, static data members are always put
5770      out in exactly those files where they are defined, just as
5771      with ordinary namespace-scope variables.  */
5772   if (!processing_template_decl)
5773     DECL_INTERFACE_KNOWN (decl) = 1;
5774 }
5775
5776 /* Create a VAR_DECL named NAME with the indicated TYPE.
5777
5778    If SCOPE is non-NULL, it is the class type or namespace containing
5779    the variable.  If SCOPE is NULL, the variable should is created in
5780    the innermost enclosings scope.  */
5781
5782 static tree
5783 grokvardecl (tree type,
5784              tree name,
5785              const cp_decl_specifier_seq *declspecs,
5786              int initialized,
5787              int constp,
5788              tree scope)
5789 {
5790   tree decl;
5791   tree explicit_scope;
5792
5793   gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
5794
5795   /* Compute the scope in which to place the variable, but remember
5796      whether or not that scope was explicitly specified by the user.   */
5797   explicit_scope = scope;
5798   if (!scope)
5799     {
5800       /* An explicit "extern" specifier indicates a namespace-scope
5801          variable.  */
5802       if (declspecs->storage_class == sc_extern)
5803         scope = current_namespace;
5804       else if (!at_function_scope_p ())
5805         scope = current_scope ();
5806     }
5807
5808   if (scope
5809       && (/* If the variable is a namespace-scope variable declared in a
5810              template, we need DECL_LANG_SPECIFIC.  */
5811           (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
5812           /* Similarly for namespace-scope variables with language linkage
5813              other than C++.  */
5814           || (TREE_CODE (scope) == NAMESPACE_DECL
5815               && current_lang_name != lang_name_cplusplus)
5816           /* Similarly for static data members.  */
5817           || TYPE_P (scope)))
5818     decl = build_lang_decl (VAR_DECL, name, type);
5819   else
5820     decl = build_decl (VAR_DECL, name, type);
5821
5822   if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
5823     set_decl_namespace (decl, explicit_scope, 0);
5824   else
5825     DECL_CONTEXT (decl) = scope;
5826
5827   if (declspecs->storage_class == sc_extern)
5828     {
5829       DECL_THIS_EXTERN (decl) = 1;
5830       DECL_EXTERNAL (decl) = !initialized;
5831     }
5832
5833   if (DECL_CLASS_SCOPE_P (decl))
5834     {
5835       set_linkage_for_static_data_member (decl);
5836       /* This function is only called with out-of-class definitions.  */
5837       DECL_EXTERNAL (decl) = 0;
5838     }
5839   /* At top level, either `static' or no s.c. makes a definition
5840      (perhaps tentative), and absence of `static' makes it public.  */
5841   else if (toplevel_bindings_p ())
5842     {
5843       TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
5844                             && (DECL_THIS_EXTERN (decl) || ! constp));
5845       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5846     }
5847   /* Not at top level, only `static' makes a static definition.  */
5848   else
5849     {
5850       TREE_STATIC (decl) = declspecs->storage_class == sc_static;
5851       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5852     }
5853
5854   if (declspecs->specs[(int)ds_thread])
5855     {
5856       if (targetm.have_tls)
5857         DECL_THREAD_LOCAL (decl) = 1;
5858       else
5859         /* A mere warning is sure to result in improper semantics
5860            at runtime.  Don't bother to allow this to compile.  */
5861         error ("thread-local storage not supported for this target");
5862     }
5863
5864   if (TREE_PUBLIC (decl))
5865     {
5866       /* [basic.link]: A name with no linkage (notably, the name of a class
5867          or enumeration declared in a local scope) shall not be used to
5868          declare an entity with linkage.
5869
5870          Only check this for public decls for now.  */
5871       tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
5872       if (t)
5873         {
5874           if (TYPE_ANONYMOUS_P (t))
5875             {
5876               if (DECL_EXTERN_C_P (decl))
5877                 /* Allow this; it's pretty common in C.  */
5878                   ;
5879               else
5880                 {
5881                   /* DRs 132, 319 and 389 seem to indicate types with
5882                      no linkage can only be used to declare extern "C"
5883                      entities.  Since it's not always an error in the
5884                      ISO C++ 90 Standard, we only issue a warning.  */
5885                   warning ("non-local variable %q#D uses anonymous type",
5886                            decl);
5887                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5888                     cp_warning_at ("%q#D does not refer to the unqualified "
5889                                    "type, so it is not used for linkage",
5890                                    TYPE_NAME (t));
5891                 }
5892             }
5893           else
5894             warning ("non-local variable %q#D uses local type %qT", decl, t);
5895         }
5896     }
5897   else
5898     DECL_INTERFACE_KNOWN (decl) = 1;
5899
5900   return decl;
5901 }
5902
5903 /* Create and return a canonical pointer to member function type, for
5904    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
5905
5906 tree
5907 build_ptrmemfunc_type (tree type)
5908 {
5909   tree field, fields;
5910   tree t;
5911   tree unqualified_variant = NULL_TREE;
5912
5913   if (type == error_mark_node)
5914     return type;
5915
5916   /* If a canonical type already exists for this type, use it.  We use
5917      this method instead of type_hash_canon, because it only does a
5918      simple equality check on the list of field members.  */
5919
5920   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
5921     return t;
5922
5923   /* Make sure that we always have the unqualified pointer-to-member
5924      type first.  */
5925   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5926     unqualified_variant
5927       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
5928
5929   t = make_aggr_type (RECORD_TYPE);
5930   xref_basetypes (t, NULL_TREE);
5931
5932   /* Let the front-end know this is a pointer to member function...  */
5933   TYPE_PTRMEMFUNC_FLAG (t) = 1;
5934   /* ... and not really an aggregate.  */
5935   SET_IS_AGGR_TYPE (t, 0);
5936
5937   field = build_decl (FIELD_DECL, pfn_identifier, type);
5938   fields = field;
5939
5940   field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
5941   TREE_CHAIN (field) = fields;
5942   fields = field;
5943
5944   finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
5945
5946   /* Zap out the name so that the back-end will give us the debugging
5947      information for this anonymous RECORD_TYPE.  */
5948   TYPE_NAME (t) = NULL_TREE;
5949
5950   /* If this is not the unqualified form of this pointer-to-member
5951      type, set the TYPE_MAIN_VARIANT for this type to be the
5952      unqualified type.  Since they are actually RECORD_TYPEs that are
5953      not variants of each other, we must do this manually.  */
5954   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5955     {
5956       t = build_qualified_type (t, cp_type_quals (type));
5957       TYPE_MAIN_VARIANT (t) = unqualified_variant;
5958       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
5959       TYPE_NEXT_VARIANT (unqualified_variant) = t;
5960     }
5961
5962   /* Cache this pointer-to-member type so that we can find it again
5963      later.  */
5964   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
5965
5966   return t;
5967 }
5968
5969 /* Create and return a pointer to data member type.  */
5970
5971 tree
5972 build_ptrmem_type (tree class_type, tree member_type)
5973 {
5974   if (TREE_CODE (member_type) == METHOD_TYPE)
5975     {
5976       tree arg_types;
5977
5978       arg_types = TYPE_ARG_TYPES (member_type);
5979       class_type = (cp_build_qualified_type
5980                     (class_type,
5981                      cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
5982       member_type
5983         = build_method_type_directly (class_type,
5984                                       TREE_TYPE (member_type),
5985                                       TREE_CHAIN (arg_types));
5986       return build_ptrmemfunc_type (build_pointer_type (member_type));
5987     }
5988   else
5989     {
5990       gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
5991       return build_offset_type (class_type, member_type);
5992     }
5993 }
5994
5995 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
5996    Check to see that the definition is valid.  Issue appropriate error
5997    messages.  Return 1 if the definition is particularly bad, or 0
5998    otherwise.  */
5999
6000 int
6001 check_static_variable_definition (tree decl, tree type)
6002 {
6003   /* Motion 10 at San Diego: If a static const integral data member is
6004      initialized with an integral constant expression, the initializer
6005      may appear either in the declaration (within the class), or in
6006      the definition, but not both.  If it appears in the class, the
6007      member is a member constant.  The file-scope definition is always
6008      required.  */
6009   if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6010     {
6011       error ("invalid in-class initialization of static data member "
6012              "of non-integral type %qT",
6013              type);
6014       /* If we just return the declaration, crashes will sometimes
6015          occur.  We therefore return void_type_node, as if this were a
6016          friend declaration, to cause callers to completely ignore
6017          this declaration.  */
6018       return 1;
6019     }
6020   else if (!CP_TYPE_CONST_P (type))
6021     error ("ISO C++ forbids in-class initialization of non-const "
6022            "static member %qD",
6023            decl);
6024   else if (pedantic && !INTEGRAL_TYPE_P (type))
6025     pedwarn ("ISO C++ forbids initialization of member constant "
6026              "%qD of non-integral type %qT", decl, type);
6027
6028   return 0;
6029 }
6030
6031 /* Given the SIZE (i.e., number of elements) in an array, compute an
6032    appropriate index type for the array.  If non-NULL, NAME is the
6033    name of the thing being declared.  */
6034
6035 tree
6036 compute_array_index_type (tree name, tree size)
6037 {
6038   tree type = TREE_TYPE (size);
6039   tree itype;
6040
6041   /* The array bound must be an integer type.  */
6042   if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6043     {
6044       if (name)
6045         error ("size of array %qD has non-integral type %qT", name, type);
6046       else
6047         error ("size of array has non-integral type %qT", type);
6048       size = integer_one_node;
6049       type = TREE_TYPE (size);
6050     }
6051
6052   if (abi_version_at_least (2)
6053       /* We should only handle value dependent expressions specially.  */
6054       ? value_dependent_expression_p (size)
6055       /* But for abi-1, we handled all instances in templates. This
6056          effects the manglings produced.  */
6057       : processing_template_decl)
6058     return build_index_type (build_min (MINUS_EXPR, sizetype,
6059                                         size, integer_one_node));
6060
6061   /* The size might be the result of a cast.  */
6062   STRIP_TYPE_NOPS (size);
6063
6064   /* It might be a const variable or enumeration constant.  */
6065   size = integral_constant_value (size);
6066
6067   /* Normally, the array-bound will be a constant.  */
6068   if (TREE_CODE (size) == INTEGER_CST)
6069     {
6070       /* Check to see if the array bound overflowed.  Make that an
6071          error, no matter how generous we're being.  */
6072       int old_flag_pedantic_errors = flag_pedantic_errors;
6073       int old_pedantic = pedantic;
6074       pedantic = flag_pedantic_errors = 1;
6075       constant_expression_warning (size);
6076       pedantic = old_pedantic;
6077       flag_pedantic_errors = old_flag_pedantic_errors;
6078
6079       /* An array must have a positive number of elements.  */
6080       if (INT_CST_LT (size, integer_zero_node))
6081         {
6082           if (name)
6083             error ("size of array %qD is negative", name);
6084           else
6085             error ("size of array is negative");
6086           size = integer_one_node;
6087         }
6088       /* As an extension we allow zero-sized arrays.  We always allow
6089          them in system headers because glibc uses them.  */
6090       else if (integer_zerop (size) && pedantic && !in_system_header)
6091         {
6092           if (name)
6093             pedwarn ("ISO C++ forbids zero-size array %qD", name);
6094           else
6095             pedwarn ("ISO C++ forbids zero-size array");
6096         }
6097     }
6098   else if (TREE_CONSTANT (size))
6099     {
6100       /* `(int) &fn' is not a valid array bound.  */
6101       if (name)
6102         error ("size of array %qD is not an integral constant-expression",
6103                name);
6104       else
6105         error ("size of array is not an integral constant-expression");
6106     }
6107   else if (pedantic)
6108     {
6109       if (name)
6110         pedwarn ("ISO C++ forbids variable-size array %qD", name);
6111       else
6112         pedwarn ("ISO C++ forbids variable-size array");
6113     }
6114
6115   if (processing_template_decl && !TREE_CONSTANT (size))
6116     /* A variable sized array.  */
6117     itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6118   else
6119     {
6120       HOST_WIDE_INT saved_processing_template_decl;
6121
6122       /* Compute the index of the largest element in the array.  It is
6123          one less than the number of elements in the array.  We save
6124          and restore PROCESSING_TEMPLATE_DECL so that computations in
6125          cp_build_binary_op will be appropriately folded.  */
6126       saved_processing_template_decl = processing_template_decl;
6127       processing_template_decl = 0;
6128       itype = cp_build_binary_op (MINUS_EXPR,
6129                                   cp_convert (ssizetype, size),
6130                                   cp_convert (ssizetype, integer_one_node));
6131       itype = fold (itype);
6132       processing_template_decl = saved_processing_template_decl;
6133
6134       if (!TREE_CONSTANT (itype))
6135         /* A variable sized array.  */
6136         itype = variable_size (itype);
6137       /* Make sure that there was no overflow when creating to a signed
6138          index type.  (For example, on a 32-bit machine, an array with
6139          size 2^32 - 1 is too big.)  */
6140       else if (TREE_OVERFLOW (itype))
6141         {
6142           error ("overflow in array dimension");
6143           TREE_OVERFLOW (itype) = 0;
6144         }
6145     }
6146
6147   /* Create and return the appropriate index type.  */
6148   return build_index_type (itype);
6149 }
6150
6151 /* Returns the scope (if any) in which the entity declared by
6152    DECLARATOR will be located.  If the entity was declared with an
6153    unqualified name, NULL_TREE is returned.  */
6154
6155 tree
6156 get_scope_of_declarator (const cp_declarator *declarator)
6157 {
6158   while (declarator && declarator->kind != cdk_id)
6159     declarator = declarator->declarator;
6160
6161   /* If the declarator-id is a SCOPE_REF, the scope in which the
6162      declaration occurs is the first operand.  */
6163   if (declarator
6164       && declarator->u.id.qualifying_scope)
6165     return declarator->u.id.qualifying_scope;
6166
6167   /* Otherwise, the declarator is not a qualified name; the entity will
6168      be declared in the current scope.  */
6169   return NULL_TREE;
6170 }
6171
6172 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6173    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
6174    with this type.  */
6175
6176 static tree
6177 create_array_type_for_decl (tree name, tree type, tree size)
6178 {
6179   tree itype = NULL_TREE;
6180   const char* error_msg;
6181
6182   /* If things have already gone awry, bail now.  */
6183   if (type == error_mark_node || size == error_mark_node)
6184     return error_mark_node;
6185
6186   /* Assume that everything will go OK.  */
6187   error_msg = NULL;
6188
6189   /* There are some types which cannot be array elements.  */
6190   switch (TREE_CODE (type))
6191     {
6192     case VOID_TYPE:
6193       error_msg = "array of void";
6194       break;
6195
6196     case FUNCTION_TYPE:
6197       error_msg = "array of functions";
6198       break;
6199
6200     case REFERENCE_TYPE:
6201       error_msg = "array of references";
6202       break;
6203
6204     case METHOD_TYPE:
6205       error_msg = "array of function members";
6206       break;
6207
6208     default:
6209       break;
6210     }
6211
6212   /* If something went wrong, issue an error-message and return.  */
6213   if (error_msg)
6214     {
6215       if (name)
6216         error ("declaration of %qD as %s", name, error_msg);
6217       else
6218         error ("creating %s", error_msg);
6219
6220       return error_mark_node;
6221     }
6222
6223   /* [dcl.array]
6224
6225      The constant expressions that specify the bounds of the arrays
6226      can be omitted only for the first member of the sequence.  */
6227   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6228     {
6229       if (name)
6230         error ("declaration of %qD as multidimensional array must "
6231                "have bounds for all dimensions except the first",
6232                name);
6233       else
6234         error ("multidimensional array must have bounds for all "
6235                "dimensions except the first");
6236
6237       return error_mark_node;
6238     }
6239
6240   /* Figure out the index type for the array.  */
6241   if (size)
6242     itype = compute_array_index_type (name, size);
6243
6244   /* [dcl.array]
6245      T is called the array element type; this type shall not be [...] an
6246      abstract class type.  */
6247   abstract_virtuals_error (name, type);
6248
6249   return build_cplus_array_type (type, itype);
6250 }
6251
6252 /* Check that it's OK to declare a function with the indicated TYPE.
6253    SFK indicates the kind of special function (if any) that this
6254    function is.  OPTYPE is the type given in a conversion operator
6255    declaration, or the class type for a constructor/destructor.
6256    Returns the actual return type of the function; that
6257    may be different than TYPE if an error occurs, or for certain
6258    special functions.  */
6259
6260 static tree
6261 check_special_function_return_type (special_function_kind sfk,
6262                                     tree type,
6263                                     tree optype)
6264 {
6265   switch (sfk)
6266     {
6267     case sfk_constructor:
6268       if (type)
6269         error ("return type specification for constructor invalid");
6270
6271       if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6272         type = build_pointer_type (optype);
6273       else
6274         type = void_type_node;
6275       break;
6276
6277     case sfk_destructor:
6278       if (type)
6279         error ("return type specification for destructor invalid");
6280       /* We can't use the proper return type here because we run into
6281          problems with ambiguous bases and covariant returns.
6282          Java classes are left unchanged because (void *) isn't a valid
6283          Java type, and we don't want to change the Java ABI.  */
6284       if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6285         type = build_pointer_type (void_type_node);
6286       else
6287         type = void_type_node;
6288       break;
6289
6290     case sfk_conversion:
6291       if (type && !same_type_p (type, optype))
6292         error ("operator %qT declared to return %qT", optype, type);
6293       else if (type)
6294         pedwarn ("return type specified for %<operator %T%>",  optype);
6295       type = optype;
6296       break;
6297
6298     default:
6299       gcc_unreachable ();
6300     }
6301
6302   return type;
6303 }
6304
6305 /* A variable or data member (whose unqualified name is IDENTIFIER)
6306    has been declared with the indicated TYPE.  If the TYPE is not
6307    acceptable, issue an error message and return a type to use for
6308    error-recovery purposes.  */
6309
6310 tree
6311 check_var_type (tree identifier, tree type)
6312 {
6313   if (VOID_TYPE_P (type))
6314     {
6315       if (!identifier)
6316         error ("unnamed variable or field declared void");
6317       else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
6318         {
6319           gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
6320           error ("variable or field %qE declared void", identifier);
6321         }
6322       else
6323         error ("variable or field declared void");
6324       type = integer_type_node;
6325     }
6326
6327   return type;
6328 }
6329
6330 /* Given declspecs and a declarator (abstract or otherwise), determine
6331    the name and type of the object declared and construct a DECL node
6332    for it.
6333
6334    DECLSPECS is a chain of tree_list nodes whose value fields
6335     are the storage classes and type specifiers.
6336
6337    DECL_CONTEXT says which syntactic context this declaration is in:
6338      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6339      FUNCDEF for a function definition.  Like NORMAL but a few different
6340       error messages in each case.  Return value may be zero meaning
6341       this definition is too screwy to try to parse.
6342      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
6343       handle member functions (which have FIELD context).
6344       Return value may be zero meaning this definition is too screwy to
6345       try to parse.
6346      PARM for a parameter declaration (either within a function prototype
6347       or before a function body).  Make a PARM_DECL, or return void_type_node.
6348      CATCHPARM for a parameter declaration before a catch clause.
6349      TYPENAME if for a typename (in a cast or sizeof).
6350       Don't make a DECL node; just return the ..._TYPE node.
6351      FIELD for a struct or union field; make a FIELD_DECL.
6352      BITFIELD for a field with specified width.
6353    INITIALIZED is 1 if the decl has an initializer.
6354
6355    ATTRLIST is a pointer to the list of attributes, which may be NULL
6356    if there are none; *ATTRLIST may be modified if attributes from inside
6357    the declarator should be applied to the declaration.
6358
6359    When this function is called, scoping variables (such as
6360    CURRENT_CLASS_TYPE) should reflect the scope in which the
6361    declaration occurs, not the scope in which the new declaration will
6362    be placed.  For example, on:
6363
6364      void S::f() { ... }
6365
6366    when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6367    should not be `S'.  */
6368
6369 tree
6370 grokdeclarator (const cp_declarator *declarator,
6371                 const cp_decl_specifier_seq *declspecs,
6372                 enum decl_context decl_context,
6373                 int initialized,
6374                 tree* attrlist)
6375 {
6376   tree type = NULL_TREE;
6377   int longlong = 0;
6378   int type_quals;
6379   int virtualp, explicitp, friendp, inlinep, staticp;
6380   int explicit_int = 0;
6381   int explicit_char = 0;
6382   int defaulted_int = 0;
6383   tree dependant_name = NULL_TREE;
6384
6385   tree typedef_decl = NULL_TREE;
6386   const char *name = NULL;
6387   tree typedef_type = NULL_TREE;
6388   int funcdef_flag = 0;
6389   cp_declarator_kind innermost_code = cdk_error;
6390   int bitfield = 0;
6391 #if 0
6392   /* See the code below that used this.  */
6393   tree decl_attr = NULL_TREE;
6394 #endif
6395
6396   /* Keep track of what sort of function is being processed
6397      so that we can warn about default return values, or explicit
6398      return values which do not match prescribed defaults.  */
6399   special_function_kind sfk = sfk_none;
6400
6401   tree dname = NULL_TREE;
6402   tree ctor_return_type = NULL_TREE;
6403   enum overload_flags flags = NO_SPECIAL;
6404   cp_cv_quals quals = TYPE_UNQUALIFIED;
6405   tree raises = NULL_TREE;
6406   int template_count = 0;
6407   tree returned_attrs = NULL_TREE;
6408   tree parms = NULL_TREE;
6409   const cp_declarator *id_declarator;
6410   /* The unqualified name of the declarator; either an
6411      IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR.  */
6412   tree unqualified_id;
6413   /* The class type, if any, in which this entity is located,
6414      or NULL_TREE if none.  Note that this value may be different from
6415      the current class type; for example if an attempt is made to declare
6416      "A::f" inside "B", this value will be "A".  */
6417   tree ctype = current_class_type;
6418   /* The NAMESPACE_DECL for the namespace in which this entity is
6419      located.  If an unqualified name is used to declare the entity,
6420      this value will be NULL_TREE, even if the entity is located at
6421      namespace scope.  */
6422   tree in_namespace = NULL_TREE;
6423   cp_decl_spec ds;
6424   cp_storage_class storage_class;
6425   bool unsigned_p, signed_p, short_p, long_p, thread_p;
6426   bool type_was_error_mark_node = false;
6427
6428   signed_p = declspecs->specs[(int)ds_signed];
6429   unsigned_p = declspecs->specs[(int)ds_unsigned];
6430   short_p = declspecs->specs[(int)ds_short];
6431   long_p = declspecs->specs[(int)ds_long];
6432   thread_p = declspecs->specs[(int)ds_thread];
6433
6434   if (decl_context == FUNCDEF)
6435     funcdef_flag = 1, decl_context = NORMAL;
6436   else if (decl_context == MEMFUNCDEF)
6437     funcdef_flag = -1, decl_context = FIELD;
6438   else if (decl_context == BITFIELD)
6439     bitfield = 1, decl_context = FIELD;
6440
6441   /* Look inside a declarator for the name being declared
6442      and get it as a string, for an error message.  */
6443   for (id_declarator = declarator;
6444        id_declarator;
6445        id_declarator = id_declarator->declarator)
6446     {
6447       if (id_declarator->kind != cdk_id)
6448         innermost_code = id_declarator->kind;
6449
6450       switch (id_declarator->kind)
6451         {
6452         case cdk_function:
6453           if (id_declarator->declarator
6454               && id_declarator->declarator->kind == cdk_id)
6455             {
6456               sfk = id_declarator->declarator->u.id.sfk;
6457               if (sfk == sfk_destructor)
6458                 flags = DTOR_FLAG;
6459             }
6460           break;
6461
6462         case cdk_id:
6463           {
6464             tree qualifying_scope = id_declarator->u.id.qualifying_scope;
6465             tree decl = id_declarator->u.id.unqualified_name;
6466             if (!decl)
6467               break;
6468             if (qualifying_scope)
6469               {
6470                 if (TYPE_P (qualifying_scope))
6471                   {
6472                     ctype = qualifying_scope;
6473                     if (innermost_code != cdk_function
6474                         && current_class_type
6475                         && !UNIQUELY_DERIVED_FROM_P (ctype,
6476                                                      current_class_type))
6477                       {
6478                         error ("type %qT is not derived from type %qT",
6479                                ctype, current_class_type);
6480                         return error_mark_node;
6481                       }
6482                   }
6483                 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
6484                   in_namespace = qualifying_scope;
6485               }
6486             if (TREE_CODE (decl) == BASELINK)
6487               decl = BASELINK_FUNCTIONS (decl);
6488             if (decl == error_mark_node)
6489               return error_mark_node;
6490             switch (TREE_CODE (decl))
6491               {
6492               case BIT_NOT_EXPR:
6493                 {
6494                   tree type;
6495
6496                   if (innermost_code != cdk_function)
6497                     {
6498                       error ("declaration of %qD as non-function", decl);
6499                       return error_mark_node;
6500                     }
6501                   else if (!qualifying_scope
6502                            && !(current_class_type && at_class_scope_p ()))
6503                     {
6504                       error ("declaration of %qD as non-member", decl);
6505                       return error_mark_node;
6506                     }
6507
6508                   type = TREE_OPERAND (decl, 0);
6509                   name = IDENTIFIER_POINTER (constructor_name (type));
6510                 }
6511                 break;
6512
6513               case TEMPLATE_ID_EXPR:
6514                 {
6515                   tree fns = TREE_OPERAND (decl, 0);
6516
6517                   dname = fns;
6518                   if (TREE_CODE (dname) == COMPONENT_REF)
6519                     dname = TREE_OPERAND (dname, 1);
6520                   if (TREE_CODE (dname) != IDENTIFIER_NODE)
6521                     {
6522                       gcc_assert (is_overloaded_fn (dname));
6523                       dname = DECL_NAME (get_first_fn (dname));
6524                     }
6525                 }
6526                 /* Fall through.  */
6527
6528               case IDENTIFIER_NODE:
6529                 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6530                   dname = decl;
6531
6532                 if (C_IS_RESERVED_WORD (dname))
6533                   {
6534                     error ("declarator-id missing; using reserved word %qD",
6535                            dname);
6536                     name = IDENTIFIER_POINTER (dname);
6537                   }
6538                 else if (!IDENTIFIER_TYPENAME_P (dname))
6539                   name = IDENTIFIER_POINTER (dname);
6540                 else
6541                   {
6542                     gcc_assert (flags == NO_SPECIAL);
6543                     flags = TYPENAME_FLAG;
6544                     ctor_return_type = TREE_TYPE (dname);
6545                     sfk = sfk_conversion;
6546                     if (is_typename_at_global_scope (dname))
6547                       name = IDENTIFIER_POINTER (dname);
6548                     else
6549                       name = "<invalid operator>";
6550                   }
6551                 break;
6552
6553               case TYPE_DECL:
6554                 dname = constructor_name (TREE_TYPE (decl));
6555                 name = IDENTIFIER_POINTER (dname);
6556                 break;
6557
6558               default:
6559                 gcc_unreachable ();
6560               }
6561             break;
6562
6563           case cdk_array:
6564           case cdk_pointer:
6565           case cdk_reference:
6566           case cdk_ptrmem:
6567             break;
6568
6569           case cdk_error:
6570             break;
6571
6572           default:
6573             gcc_unreachable ();
6574           }
6575         }
6576       if (id_declarator->kind == cdk_id)
6577         break;
6578     }
6579
6580   /* A function definition's declarator must have the form of
6581      a function declarator.  */
6582
6583   if (funcdef_flag && innermost_code != cdk_function)
6584     return 0;
6585
6586   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
6587       && innermost_code != cdk_function
6588       && ! (ctype && !declspecs->any_specifiers_p))
6589     {
6590       error ("declaration of %qD as non-function", dname);
6591       return error_mark_node;
6592     }
6593
6594   /* Anything declared one level down from the top level
6595      must be one of the parameters of a function
6596      (because the body is at least two levels down).  */
6597
6598   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6599      by not allowing C++ class definitions to specify their parameters
6600      with xdecls (must be spec.d in the parmlist).
6601
6602      Since we now wait to push a class scope until we are sure that
6603      we are in a legitimate method context, we must set oldcname
6604      explicitly (since current_class_name is not yet alive).
6605
6606      We also want to avoid calling this a PARM if it is in a namespace.  */
6607
6608   if (decl_context == NORMAL && !toplevel_bindings_p ())
6609     {
6610       struct cp_binding_level *b = current_binding_level;
6611       current_binding_level = b->level_chain;
6612       if (current_binding_level != 0 && toplevel_bindings_p ())
6613         decl_context = PARM;
6614       current_binding_level = b;
6615     }
6616
6617   if (name == NULL)
6618     name = decl_context == PARM ? "parameter" : "type name";
6619
6620   /* If there were multiple types specified in the decl-specifier-seq,
6621      issue an error message.  */
6622   if (declspecs->multiple_types_p)
6623     error ("two or more data types in declaration of %qs", name);
6624   /* Extract the basic type from the decl-specifier-seq.  */
6625   type = declspecs->type;
6626   if (type == error_mark_node)
6627     {
6628       type = NULL_TREE;
6629       type_was_error_mark_node = true;
6630     }
6631   /* If the entire declaration is itself tagged as deprecated then
6632      suppress reports of deprecated items.  */
6633   if (type && TREE_DEPRECATED (type)
6634       && deprecated_state != DEPRECATED_SUPPRESS)
6635     warn_deprecated_use (type);
6636   if (type && TREE_CODE (type) == TYPE_DECL)
6637     {
6638       typedef_decl = type;
6639       type = TREE_TYPE (typedef_decl);
6640     }
6641   /* No type at all: default to `int', and set DEFAULTED_INT
6642      because it was not a user-defined typedef.  */
6643   if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
6644     {
6645       /* These imply 'int'.  */
6646       type = integer_type_node;
6647       defaulted_int = 1;
6648     }
6649   /* Gather flags.  */
6650   explicit_int = declspecs->explicit_int_p;
6651   explicit_char = declspecs->explicit_char_p;
6652
6653   /* Check for repeated decl-specifiers.  */
6654   for (ds = ds_first; ds != ds_last; ++ds)
6655     {
6656       unsigned count = declspecs->specs[(int)ds];
6657       if (count < 2)
6658         continue;
6659       /* The "long" specifier is a special case because of
6660          "long long".  */
6661       if (ds == ds_long)
6662         {
6663           if (count > 2)
6664             error ("%<long long long%> is too long for GCC");
6665           else if (pedantic && !in_system_header && warn_long_long)
6666             pedwarn ("ISO C++ does not support %<long long%>");
6667           else
6668             longlong = 1;
6669         }
6670       else if (declspecs->specs[(int)ds] > 1)
6671         {
6672           static const char *const decl_spec_names[] = {
6673             "signed",
6674             "unsigned",
6675             "short",
6676             "long",
6677             "const",
6678             "volatile",
6679             "restrict",
6680             "inline",
6681             "virtual",
6682             "explicit",
6683             "friend",
6684             "typedef",
6685             "__complex",
6686             "__thread"
6687           };
6688           error ("duplicate %qs", decl_spec_names[(int)ds]);
6689         }
6690     }
6691
6692 #if 0
6693   /* See the code below that used this.  */
6694   if (typedef_decl)
6695     decl_attr = DECL_ATTRIBUTES (typedef_decl);
6696 #endif
6697   typedef_type = type;
6698
6699
6700   if (sfk != sfk_conversion)
6701     ctor_return_type = ctype;
6702
6703   if (sfk != sfk_none)
6704     type = check_special_function_return_type (sfk, type,
6705                                                ctor_return_type);
6706   else if (type == NULL_TREE)
6707     {
6708       int is_main;
6709
6710       explicit_int = -1;
6711
6712       /* We handle `main' specially here, because 'main () { }' is so
6713          common.  With no options, it is allowed.  With -Wreturn-type,
6714          it is a warning.  It is only an error with -pedantic-errors.  */
6715       is_main = (funcdef_flag
6716                  && dname && MAIN_NAME_P (dname)
6717                  && ctype == NULL_TREE
6718                  && in_namespace == NULL_TREE
6719                  && current_namespace == global_namespace);
6720
6721       if (type_was_error_mark_node)
6722         /* We've already issued an error, don't complain more.  */;
6723       else if (in_system_header || flag_ms_extensions)
6724         /* Allow it, sigh.  */;
6725       else if (pedantic || ! is_main)
6726         pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
6727       else if (warn_return_type)
6728         warning ("ISO C++ forbids declaration of %qs with no type", name);
6729
6730       type = integer_type_node;
6731     }
6732
6733   ctype = NULL_TREE;
6734
6735   /* Now process the modifiers that were specified
6736      and check for invalid combinations.  */
6737
6738   /* Long double is a special combination.  */
6739   if (long_p && TYPE_MAIN_VARIANT (type) == double_type_node)
6740     {
6741       long_p = false;
6742       type = build_qualified_type (long_double_type_node,
6743                                    cp_type_quals (type));
6744     }
6745
6746   /* Check all other uses of type modifiers.  */
6747
6748   if (unsigned_p || signed_p || long_p || short_p)
6749     {
6750       int ok = 0;
6751
6752       if (TREE_CODE (type) == REAL_TYPE)
6753         error ("short, signed or unsigned invalid for %qs", name);
6754       else if (TREE_CODE (type) != INTEGER_TYPE)
6755         error ("long, short, signed or unsigned invalid for %qs", name);
6756       else if (long_p && short_p)
6757         error ("long and short specified together for %qs", name);
6758       else if ((long_p || short_p) && explicit_char)
6759         error ("long or short specified with char for %qs", name);
6760       else if ((long_p|| short_p) && TREE_CODE (type) == REAL_TYPE)
6761         error ("long or short specified with floating type for %qs", name);
6762       else if (signed_p && unsigned_p)
6763         error ("signed and unsigned given together for %qs", name);
6764       else
6765         {
6766           ok = 1;
6767           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
6768             {
6769               pedwarn ("long, short, signed or unsigned used invalidly for %qs",
6770                        name);
6771               if (flag_pedantic_errors)
6772                 ok = 0;
6773             }
6774         }
6775
6776       /* Discard the type modifiers if they are invalid.  */
6777       if (! ok)
6778         {
6779           unsigned_p = false;
6780           signed_p = false;
6781           long_p = false;
6782           short_p = false;
6783           longlong = 0;
6784         }
6785     }
6786
6787   /* Decide whether an integer type is signed or not.
6788      Optionally treat bitfields as signed by default.  */
6789   if (unsigned_p
6790       /* [class.bit]
6791
6792          It is implementation-defined whether a plain (neither
6793          explicitly signed or unsigned) char, short, int, or long
6794          bit-field is signed or unsigned.
6795
6796          Naturally, we extend this to long long as well.  Note that
6797          this does not include wchar_t.  */
6798       || (bitfield && !flag_signed_bitfields
6799           && !signed_p
6800           /* A typedef for plain `int' without `signed' can be
6801              controlled just like plain `int', but a typedef for
6802              `signed int' cannot be so controlled.  */
6803           && !(typedef_decl
6804                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
6805           && (TREE_CODE (type) == INTEGER_TYPE
6806               || TREE_CODE (type) == CHAR_TYPE)
6807           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
6808     {
6809       if (longlong)
6810         type = long_long_unsigned_type_node;
6811       else if (long_p)
6812         type = long_unsigned_type_node;
6813       else if (short_p)
6814         type = short_unsigned_type_node;
6815       else if (type == char_type_node)
6816         type = unsigned_char_type_node;
6817       else if (typedef_decl)
6818         type = c_common_unsigned_type (type);
6819       else
6820         type = unsigned_type_node;
6821     }
6822   else if (signed_p && type == char_type_node)
6823     type = signed_char_type_node;
6824   else if (longlong)
6825     type = long_long_integer_type_node;
6826   else if (long_p)
6827     type = long_integer_type_node;
6828   else if (short_p)
6829     type = short_integer_type_node;
6830
6831   if (declspecs->specs[(int)ds_complex])
6832     {
6833       if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
6834         error ("complex invalid for %qs", name);
6835       /* If we just have "complex", it is equivalent to
6836          "complex double", but if any modifiers at all are specified it is
6837          the complex form of TYPE.  E.g, "complex short" is
6838          "complex short int".  */
6839
6840       else if (defaulted_int && ! longlong
6841                && ! (long_p || short_p || signed_p || unsigned_p))
6842         type = complex_double_type_node;
6843       else if (type == integer_type_node)
6844         type = complex_integer_type_node;
6845       else if (type == float_type_node)
6846         type = complex_float_type_node;
6847       else if (type == double_type_node)
6848         type = complex_double_type_node;
6849       else if (type == long_double_type_node)
6850         type = complex_long_double_type_node;
6851       else
6852         type = build_complex_type (type);
6853     }
6854
6855   type_quals = TYPE_UNQUALIFIED;
6856   if (declspecs->specs[(int)ds_const])
6857     type_quals |= TYPE_QUAL_CONST;
6858   if (declspecs->specs[(int)ds_volatile])
6859     type_quals |= TYPE_QUAL_VOLATILE;
6860   if (declspecs->specs[(int)ds_restrict])
6861     type_quals |= TYPE_QUAL_RESTRICT;
6862   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
6863     error ("qualifiers are not allowed on declaration of %<operator %T%>",
6864            ctor_return_type);
6865
6866   if (TREE_CODE (type) == FUNCTION_TYPE
6867       && type_quals != TYPE_UNQUALIFIED)
6868     {
6869       /* This was an error in C++98 (cv-qualifiers cannot be added to
6870          a function type), but DR 295 makes the code well-formed by
6871          dropping the extra qualifiers. */
6872       if (pedantic)
6873         {
6874           tree bad_type = build_qualified_type (type, type_quals);
6875           pedwarn ("ignoring %qV qualifiers added to function type %qT",
6876                    bad_type, type);
6877         }
6878       type_quals = TYPE_UNQUALIFIED;
6879     }
6880   type_quals |= cp_type_quals (type);
6881   type = cp_build_qualified_type_real
6882     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
6883                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
6884   /* We might have ignored or rejected some of the qualifiers.  */
6885   type_quals = cp_type_quals (type);
6886
6887   staticp = 0;
6888   inlinep = !! declspecs->specs[(int)ds_inline];
6889   virtualp = !! declspecs->specs[(int)ds_virtual];
6890   explicitp = !! declspecs->specs[(int)ds_explicit];
6891
6892   storage_class = declspecs->storage_class;
6893   if (storage_class == sc_static)
6894     staticp = 1 + (decl_context == FIELD);
6895
6896   if (virtualp && staticp == 2)
6897     {
6898       error ("member %qD cannot be declared both virtual and static", dname);
6899       staticp = 0;
6900     }
6901   friendp = !! declspecs->specs[(int)ds_friend];
6902
6903   if (dependant_name && !friendp)
6904     {
6905       error ("%<%T::%D%> is not a valid declarator", ctype, dependant_name);
6906       return void_type_node;
6907     }
6908
6909   /* Issue errors about use of storage classes for parameters.  */
6910   if (decl_context == PARM)
6911     {
6912       if (declspecs->specs[(int)ds_typedef])
6913         error ("typedef declaration invalid in parameter declaration");
6914       else if (storage_class == sc_static
6915                || storage_class == sc_extern
6916                || thread_p)
6917         error ("storage class specifiers invalid in parameter declarations");
6918     }
6919
6920   /* Give error if `virtual' is used outside of class declaration.  */
6921   if (virtualp
6922       && (current_class_name == NULL_TREE || decl_context != FIELD))
6923     {
6924       error ("virtual outside class declaration");
6925       virtualp = 0;
6926     }
6927
6928   /* Static anonymous unions are dealt with here.  */
6929   if (staticp && decl_context == TYPENAME
6930       && declspecs->type
6931       && ANON_AGGR_TYPE_P (declspecs->type))
6932     decl_context = FIELD;
6933
6934   /* Warn about storage classes that are invalid for certain
6935      kinds of declarations (parameters, typenames, etc.).  */
6936   if (declspecs->multiple_storage_classes_p)
6937     error ("multiple storage classes in declaration of %qs", name);
6938   else if (thread_p
6939            && ((storage_class
6940                 && storage_class != sc_extern
6941                 && storage_class != sc_static)
6942                || declspecs->specs[(int)ds_typedef]))
6943     {
6944       error ("multiple storage classes in declaration of %qs", name);
6945       thread_p = false;
6946     }
6947   else if (decl_context != NORMAL
6948            && ((storage_class != sc_none
6949                 && storage_class != sc_mutable)
6950                || thread_p))
6951     {
6952       if ((decl_context == PARM || decl_context == CATCHPARM)
6953           && (storage_class == sc_register
6954               || storage_class == sc_auto))
6955         ;
6956       else if (declspecs->specs[(int)ds_typedef])
6957         ;
6958       else if (decl_context == FIELD
6959                /* C++ allows static class elements.  */
6960                && storage_class == sc_static)
6961         /* C++ also allows inlines and signed and unsigned elements,
6962            but in those cases we don't come in here.  */
6963         ;
6964       else
6965         {
6966           if (decl_context == FIELD)
6967             {
6968               tree tmp = NULL_TREE;
6969               int op = 0;
6970
6971               if (declarator)
6972                 {
6973                   /* Avoid trying to get an operand off an identifier node.  */
6974                   if (declarator->kind != cdk_id)
6975                     tmp = declarator->declarator->u.id.unqualified_name;
6976                   else
6977                     tmp = declarator->u.id.unqualified_name;
6978                   op = IDENTIFIER_OPNAME_P (tmp);
6979                   if (IDENTIFIER_TYPENAME_P (tmp))
6980                     {
6981                       if (is_typename_at_global_scope (tmp))
6982                         name = IDENTIFIER_POINTER (tmp);
6983                       else
6984                         name = "<invalid operator>";
6985                     }
6986                 }
6987               error ("storage class specified for %s %qs",
6988                      op ? "member operator" : "field",
6989                      name);
6990             }
6991           else
6992             {
6993               if (decl_context == PARM || decl_context == CATCHPARM)
6994                 error ("storage class specified for parameter %qs", name);
6995               else
6996                 error ("storage class specified for typename");
6997             }
6998           if (storage_class == sc_register
6999               || storage_class == sc_auto
7000               || storage_class == sc_extern
7001               || thread_p)
7002             storage_class = sc_none;
7003         }
7004     }
7005   else if (storage_class == sc_extern && initialized
7006            && !funcdef_flag)
7007     {
7008       if (toplevel_bindings_p ())
7009         {
7010           /* It's common practice (and completely valid) to have a const
7011              be initialized and declared extern.  */
7012           if (!(type_quals & TYPE_QUAL_CONST))
7013             warning ("%qs initialized and declared %<extern%>", name);
7014         }
7015       else
7016         error ("%qs has both %<extern%> and initializer", name);
7017     }
7018   else if (storage_class == sc_extern && funcdef_flag
7019            && ! toplevel_bindings_p ())
7020     error ("nested function %qs declared %<extern%>", name);
7021   else if (toplevel_bindings_p ())
7022     {
7023       if (storage_class == sc_auto)
7024         error ("top-level declaration of %qs specifies %<auto%>", name);
7025     }
7026   else if (thread_p
7027            && storage_class != sc_extern
7028            && storage_class != sc_static)
7029     {
7030       error ("function-scope %qs implicitly auto and declared %<__thread%>",
7031              name);
7032       thread_p = false;
7033     }
7034
7035   if (storage_class && friendp)
7036     error ("storage class specifiers invalid in friend function declarations");
7037
7038   if (!id_declarator)
7039     unqualified_id = NULL_TREE;
7040   else
7041     {
7042       unqualified_id = id_declarator->u.id.unqualified_name;
7043       if (TREE_CODE (unqualified_id) == BASELINK)
7044         unqualified_id = BASELINK_FUNCTIONS (unqualified_id);
7045       switch (TREE_CODE (unqualified_id))
7046         {
7047         case BIT_NOT_EXPR:
7048           unqualified_id
7049             = constructor_name (TREE_OPERAND (unqualified_id, 0));
7050           break;
7051
7052         case TYPE_DECL:
7053           unqualified_id
7054             = constructor_name (TREE_TYPE (unqualified_id));
7055           break;
7056
7057         case IDENTIFIER_NODE:
7058         case TEMPLATE_ID_EXPR:
7059           break;
7060
7061         default:
7062           gcc_unreachable ();
7063         }
7064     }
7065
7066   /* Determine the type of the entity declared by recurring on the
7067      declarator.  */
7068   for (; declarator; declarator = declarator->declarator)
7069     {
7070       const cp_declarator *inner_declarator;
7071       tree attrs;
7072
7073       if (type == error_mark_node)
7074         return error_mark_node;
7075
7076       attrs = declarator->attributes;
7077       if (attrs)
7078         {
7079           int attr_flags;
7080
7081           attr_flags = 0;
7082           if (declarator == NULL || declarator->kind == cdk_id)
7083             attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7084           if (declarator->kind == cdk_function)
7085             attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7086           if (declarator->kind == cdk_array)
7087             attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7088           returned_attrs = decl_attributes (&type,
7089                                             chainon (returned_attrs, attrs),
7090                                             attr_flags);
7091         }
7092
7093       if (declarator->kind == cdk_id)
7094         break;
7095
7096       inner_declarator = declarator->declarator;
7097
7098       switch (declarator->kind)
7099         {
7100         case cdk_array:
7101           type = create_array_type_for_decl (dname, type,
7102                                              declarator->u.array.bounds);
7103           break;
7104
7105         case cdk_function:
7106           {
7107             tree arg_types;
7108             int funcdecl_p;
7109
7110             /* Declaring a function type.
7111                Make sure we have a valid type for the function to return.  */
7112
7113             /* We now know that the TYPE_QUALS don't apply to the
7114                decl, but to its return type.  */
7115             type_quals = TYPE_UNQUALIFIED;
7116
7117             /* Warn about some types functions can't return.  */
7118
7119             if (TREE_CODE (type) == FUNCTION_TYPE)
7120               {
7121                 error ("%qs declared as function returning a function", name);
7122                 type = integer_type_node;
7123               }
7124             if (TREE_CODE (type) == ARRAY_TYPE)
7125               {
7126                 error ("%qs declared as function returning an array", name);
7127                 type = integer_type_node;
7128               }
7129
7130             /* Pick up type qualifiers which should be applied to `this'.  */
7131             quals = declarator->u.function.qualifiers;
7132
7133             /* Pick up the exception specifications.  */
7134             raises = declarator->u.function.exception_specification;
7135
7136             /* Say it's a definition only for the CALL_EXPR
7137                closest to the identifier.  */
7138             funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7139
7140             if (ctype == NULL_TREE
7141                 && decl_context == FIELD
7142                 && funcdecl_p
7143                 && (friendp == 0 || dname == current_class_name))
7144               ctype = current_class_type;
7145
7146             if (ctype && sfk == sfk_conversion)
7147               TYPE_HAS_CONVERSION (ctype) = 1;
7148             if (ctype && (sfk == sfk_constructor
7149                           || sfk == sfk_destructor))
7150               {
7151                 /* We are within a class's scope. If our declarator name
7152                    is the same as the class name, and we are defining
7153                    a function, then it is a constructor/destructor, and
7154                    therefore returns a void type.  */
7155
7156                 if (flags == DTOR_FLAG)
7157                   {
7158                     /* ISO C++ 12.4/2.  A destructor may not be
7159                        declared const or volatile.  A destructor may
7160                        not be static.  */
7161                     if (staticp == 2)
7162                       error ("destructor cannot be static member function");
7163                     if (quals)
7164                       {
7165                         error ("destructors may not be cv-qualified");
7166                         quals = TYPE_UNQUALIFIED;
7167                       }
7168                     if (decl_context == FIELD)
7169                       {
7170                         if (! member_function_or_else (ctype,
7171                                                        current_class_type,
7172                                                        flags))
7173                           return void_type_node;
7174                       }
7175                   }
7176                 else            /* It's a constructor.  */
7177                   {
7178                     if (explicitp == 1)
7179                       explicitp = 2;
7180                     /* ISO C++ 12.1.  A constructor may not be
7181                        declared const or volatile.  A constructor may
7182                        not be virtual.  A constructor may not be
7183                        static.  */
7184                     if (staticp == 2)
7185                       error ("constructor cannot be static member function");
7186                     if (virtualp)
7187                       {
7188                         pedwarn ("constructors cannot be declared virtual");
7189                         virtualp = 0;
7190                       }
7191                     if (quals)
7192                       {
7193                         error ("constructors may not be cv-qualified");
7194                         quals = TYPE_UNQUALIFIED;
7195                       }
7196                     if (decl_context == FIELD)
7197                       {
7198                         if (! member_function_or_else (ctype,
7199                                                        current_class_type,
7200                                                        flags))
7201                           return void_type_node;
7202                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
7203                         if (sfk != sfk_constructor)
7204                           return NULL_TREE;
7205                       }
7206                   }
7207                 if (decl_context == FIELD)
7208                   staticp = 0;
7209               }
7210             else if (friendp)
7211               {
7212                 if (initialized)
7213                   error ("can't initialize friend function %qs", name);
7214                 if (virtualp)
7215                   {
7216                     /* Cannot be both friend and virtual.  */
7217                     error ("virtual functions cannot be friends");
7218                     friendp = 0;
7219                   }
7220                 if (decl_context == NORMAL)
7221                   error ("friend declaration not in class definition");
7222                 if (current_function_decl && funcdef_flag)
7223                   error ("can't define friend function %qs in a local "
7224                          "class definition",
7225                          name);
7226               }
7227
7228             arg_types = grokparms (declarator->u.function.parameters,
7229                                    &parms);
7230
7231             if (inner_declarator
7232                 && inner_declarator->kind == cdk_id
7233                 && inner_declarator->u.id.sfk == sfk_destructor
7234                 && arg_types != void_list_node)
7235               {
7236                 error ("destructors may not have parameters");
7237                 arg_types = void_list_node;
7238                 parms = NULL_TREE;
7239               }
7240
7241             type = build_function_type (type, arg_types);
7242             type = cp_build_qualified_type (type, quals);
7243           }
7244           break;
7245
7246         case cdk_pointer:
7247         case cdk_reference:
7248         case cdk_ptrmem:
7249           /* Filter out pointers-to-references and references-to-references.
7250              We can get these if a TYPE_DECL is used.  */
7251
7252           if (TREE_CODE (type) == REFERENCE_TYPE)
7253             {
7254               error (declarator->kind == cdk_reference
7255                      ? "cannot declare reference to %q#T"
7256                      : "cannot declare pointer to %q#T", type);
7257               type = TREE_TYPE (type);
7258             }
7259           else if (VOID_TYPE_P (type))
7260             {
7261               if (declarator->kind == cdk_reference)
7262                 error ("cannot declare reference to %q#T", type);
7263               else if (declarator->kind == cdk_ptrmem)
7264                 error ("cannot declare pointer to %q#T member", type);
7265             }
7266
7267           /* We now know that the TYPE_QUALS don't apply to the decl,
7268              but to the target of the pointer.  */
7269           type_quals = TYPE_UNQUALIFIED;
7270
7271           if (declarator->kind == cdk_ptrmem
7272               && (TREE_CODE (type) == FUNCTION_TYPE
7273                   || (quals && TREE_CODE (type) == METHOD_TYPE)))
7274             {
7275               tree dummy;
7276
7277               /* If the type is a FUNCTION_TYPE, pick up the
7278                  qualifiers from that function type. No other
7279                  qualifiers may be supplied. */
7280               if (TREE_CODE (type) == FUNCTION_TYPE)
7281                 quals = cp_type_quals (type);
7282
7283               dummy = build_decl (TYPE_DECL, NULL_TREE, type);
7284               grok_method_quals (declarator->u.pointer.class_type,
7285                                  dummy, quals);
7286               type = TREE_TYPE (dummy);
7287               quals = TYPE_UNQUALIFIED;
7288             }
7289
7290           if (declarator->kind == cdk_reference)
7291             {
7292               if (!VOID_TYPE_P (type))
7293                 type = build_reference_type (type);
7294             }
7295           else if (TREE_CODE (type) == METHOD_TYPE)
7296             type = build_ptrmemfunc_type (build_pointer_type (type));
7297           else if (declarator->kind == cdk_ptrmem)
7298             {
7299               /* We might have parsed a namespace as the class type.  */
7300               if (TREE_CODE (declarator->u.pointer.class_type)
7301                   == NAMESPACE_DECL)
7302                 {
7303                   error ("%qD is a namespace",
7304                          declarator->u.pointer.class_type);
7305                   type = build_pointer_type (type);
7306                 }
7307               else if (declarator->u.pointer.class_type == error_mark_node)
7308                 /* We will already have complained.  */
7309                 type = error_mark_node;
7310               else
7311                 type = build_ptrmem_type (declarator->u.pointer.class_type,
7312                                           type);
7313             }
7314           else
7315             type = build_pointer_type (type);
7316
7317           /* Process a list of type modifier keywords (such as
7318              const or volatile) that were given inside the `*' or `&'.  */
7319
7320           if (declarator->u.pointer.qualifiers)
7321             {
7322               type
7323                 = cp_build_qualified_type (type,
7324                                            declarator->u.pointer.qualifiers);
7325               type_quals = cp_type_quals (type);
7326             }
7327           ctype = NULL_TREE;
7328           break;
7329
7330         case cdk_error:
7331           break;
7332
7333         default:
7334           gcc_unreachable ();
7335         }
7336     }
7337
7338   if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
7339       && TREE_CODE (type) != FUNCTION_TYPE
7340       && TREE_CODE (type) != METHOD_TYPE)
7341     {
7342       error ("template-id %qD used as a declarator",
7343              unqualified_id);
7344       unqualified_id = dname;
7345     }
7346
7347   /* If DECLARATOR is non-NULL, we know it is a cdk_id declarator;
7348      otherwise, we would not have exited the loop above.  */
7349   if (declarator
7350       && declarator->u.id.qualifying_scope
7351       && TYPE_P (declarator->u.id.qualifying_scope))
7352     {
7353       tree t;
7354
7355       ctype = declarator->u.id.qualifying_scope;
7356       ctype = TYPE_MAIN_VARIANT (ctype);
7357       t = ctype;
7358       while (t != NULL_TREE && CLASS_TYPE_P (t))
7359         {
7360           /* You're supposed to have one `template <...>' for every
7361              template class, but you don't need one for a full
7362              specialization.  For example:
7363
7364                template <class T> struct S{};
7365                template <> struct S<int> { void f(); };
7366                void S<int>::f () {}
7367
7368              is correct; there shouldn't be a `template <>' for the
7369              definition of `S<int>::f'.  */
7370           if (CLASSTYPE_TEMPLATE_INFO (t)
7371               && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
7372                   || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
7373               && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7374             template_count += 1;
7375
7376           t = TYPE_MAIN_DECL (t);
7377           t = DECL_CONTEXT (t);
7378         }
7379
7380       if (ctype == current_class_type)
7381         {
7382           /* class A {
7383                void A::f ();
7384              };
7385
7386              Is this ill-formed?  */
7387
7388           if (pedantic)
7389             pedwarn ("extra qualification %<%T::%> on member %qs ignored",
7390                         ctype, name);
7391         }
7392       else if (TREE_CODE (type) == FUNCTION_TYPE)
7393         {
7394           tree sname = declarator->u.id.unqualified_name;
7395
7396           if (TREE_CODE (sname) == IDENTIFIER_NODE
7397               && NEW_DELETE_OPNAME_P (sname))
7398             /* Overloaded operator new and operator delete
7399                are always static functions.  */
7400             ;
7401           else if (current_class_type == NULL_TREE || friendp)
7402             type
7403               = build_method_type_directly (ctype,
7404                                             TREE_TYPE (type),
7405                                             TYPE_ARG_TYPES (type));
7406           else
7407             {
7408               error ("cannot declare member function %<%T::%s%> within %<%T%>",
7409                      ctype, name, current_class_type);
7410               return error_mark_node;
7411             }
7412         }
7413       else if (declspecs->specs[(int)ds_typedef]
7414                || COMPLETE_TYPE_P (complete_type (ctype)))
7415         {
7416           /* Have to move this code elsewhere in this function.
7417              this code is used for i.e., typedef int A::M; M *pm;
7418
7419              It is?  How? jason 10/2/94 */
7420
7421           if (current_class_type)
7422             {
7423               error ("cannot declare member %<%T::%s%> within %qT",
7424                      ctype, name, current_class_type);
7425               return void_type_node;
7426             }
7427         }
7428       else
7429         {
7430           cxx_incomplete_type_error (NULL_TREE, ctype);
7431           return error_mark_node;
7432         }
7433     }
7434
7435   if (returned_attrs)
7436     {
7437       if (attrlist)
7438         *attrlist = chainon (returned_attrs, *attrlist);
7439       else
7440         attrlist = &returned_attrs;
7441     }
7442
7443   /* Now TYPE has the actual type.  */
7444
7445   /* Did array size calculations overflow?  */
7446
7447   if (TREE_CODE (type) == ARRAY_TYPE
7448       && COMPLETE_TYPE_P (type)
7449       && TREE_OVERFLOW (TYPE_SIZE (type)))
7450     {
7451       error ("size of array %qs is too large", name);
7452       /* If we proceed with the array type as it is, we'll eventually
7453          crash in tree_low_cst().  */
7454       type = error_mark_node;
7455     }
7456
7457   if ((decl_context == FIELD || decl_context == PARM)
7458       && !processing_template_decl
7459       && variably_modified_type_p (type, NULL_TREE))
7460     {
7461       if (decl_context == FIELD)
7462         error ("data member may not have variably modified type %qT", type);
7463       else
7464         error ("parameter may not have variably modified type %qT", type);
7465       type = error_mark_node;
7466     }
7467
7468   if (explicitp == 1 || (explicitp && friendp))
7469     {
7470       /* [dcl.fct.spec] The explicit specifier shall only be used in
7471          declarations of constructors within a class definition.  */
7472       error ("only declarations of constructors can be %<explicit%>");
7473       explicitp = 0;
7474     }
7475
7476   if (storage_class == sc_mutable)
7477     {
7478       if (decl_context != FIELD || friendp)
7479         {
7480           error ("non-member %qs cannot be declared %<mutable%>", name);
7481           storage_class = sc_none;
7482         }
7483       else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
7484         {
7485           error ("non-object member %qs cannot be declared %<mutable%>", name);
7486           storage_class = sc_none;
7487         }
7488       else if (TREE_CODE (type) == FUNCTION_TYPE
7489                || TREE_CODE (type) == METHOD_TYPE)
7490         {
7491           error ("function %qs cannot be declared %<mutable%>", name);
7492           storage_class = sc_none;
7493         }
7494       else if (staticp)
7495         {
7496           error ("static %qs cannot be declared %<mutable%>", name);
7497           storage_class = sc_none;
7498         }
7499       else if (type_quals & TYPE_QUAL_CONST)
7500         {
7501           error ("const %qs cannot be declared %<mutable%>", name);
7502           storage_class = sc_none;
7503         }
7504     }
7505
7506   /* If this is declaring a typedef name, return a TYPE_DECL.  */
7507   if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
7508     {
7509       tree decl;
7510
7511       /* Note that the grammar rejects storage classes
7512          in typenames, fields or parameters.  */
7513       if (current_lang_name == lang_name_java)
7514         TYPE_FOR_JAVA (type) = 1;
7515
7516       if (decl_context == FIELD)
7517         decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
7518       else
7519         decl = build_decl (TYPE_DECL, unqualified_id, type);
7520       if (id_declarator && declarator->u.id.qualifying_scope)
7521         error ("%Jtypedef name may not be a nested-name-specifier", decl);
7522
7523       if (decl_context != FIELD)
7524         {
7525           if (!current_function_decl)
7526             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7527           else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
7528                    || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
7529                        (current_function_decl)))
7530             /* The TYPE_DECL is "abstract" because there will be
7531                clones of this constructor/destructor, and there will
7532                be copies of this TYPE_DECL generated in those
7533                clones.  */
7534             DECL_ABSTRACT (decl) = 1;
7535         }
7536       else if (constructor_name_p (unqualified_id, current_class_type))
7537         pedwarn ("ISO C++ forbids nested type %qD with same name "
7538                  "as enclosing class",
7539                  unqualified_id);
7540
7541       /* If the user declares "typedef struct {...} foo" then the
7542          struct will have an anonymous name.  Fill that name in now.
7543          Nothing can refer to it, so nothing needs know about the name
7544          change.  */
7545       if (type != error_mark_node
7546           && unqualified_id
7547           && TYPE_NAME (type)
7548           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7549           && TYPE_ANONYMOUS_P (type)
7550           /* Don't do this if there are attributes.  */
7551           && (!attrlist || !*attrlist)
7552           && cp_type_quals (type) == TYPE_UNQUALIFIED)
7553         {
7554           tree oldname = TYPE_NAME (type);
7555           tree t;
7556
7557           /* Replace the anonymous name with the real name everywhere.  */
7558           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7559             if (TYPE_NAME (t) == oldname)
7560               TYPE_NAME (t) = decl;
7561
7562           if (TYPE_LANG_SPECIFIC (type))
7563             TYPE_WAS_ANONYMOUS (type) = 1;
7564
7565           /* If this is a typedef within a template class, the nested
7566              type is a (non-primary) template.  The name for the
7567              template needs updating as well.  */
7568           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7569             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7570               = TYPE_IDENTIFIER (type);
7571
7572           /* FIXME remangle member functions; member functions of a
7573              type with external linkage have external linkage.  */
7574         }
7575
7576       if (quals)
7577         {
7578           if (ctype == NULL_TREE)
7579             {
7580               if (TREE_CODE (type) == METHOD_TYPE)
7581                 ctype = TYPE_METHOD_BASETYPE (type);
7582               /* Any qualifiers on a function type typedef have
7583                  already been dealt with. */
7584               else if (TREE_CODE (type) == FUNCTION_TYPE)
7585                 quals = TYPE_UNQUALIFIED;
7586             }
7587           if (ctype != NULL_TREE)
7588             grok_method_quals (ctype, decl, quals);
7589         }
7590
7591       if (signed_p
7592           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7593         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7594
7595       bad_specifiers (decl, "type", virtualp, quals != TYPE_UNQUALIFIED,
7596                       inlinep, friendp, raises != NULL_TREE);
7597
7598       return decl;
7599     }
7600
7601   /* Detect the case of an array type of unspecified size
7602      which came, as such, direct from a typedef name.
7603      We must copy the type, so that the array's domain can be
7604      individually set by the object's initializer.  */
7605
7606   if (type && typedef_type
7607       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
7608       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
7609     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
7610
7611   /* Detect where we're using a typedef of function type to declare a
7612      function. PARMS will not be set, so we must create it now.  */
7613
7614   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
7615     {
7616       tree decls = NULL_TREE;
7617       tree args;
7618
7619       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
7620         {
7621           tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
7622
7623           TREE_CHAIN (decl) = decls;
7624           decls = decl;
7625         }
7626
7627       parms = nreverse (decls);
7628
7629       if (decl_context != TYPENAME)
7630         {
7631           /* A cv-qualifier-seq shall only be part of the function type
7632              for a non-static member function. [8.3.5/4 dcl.fct] */
7633           if (cp_type_quals (type) != TYPE_UNQUALIFIED
7634               && (current_class_type == NULL_TREE || staticp) )
7635             {
7636               error ("qualified function types cannot be used to declare %s functions",
7637                      (staticp? "static member" : "free"));
7638               type = TYPE_MAIN_VARIANT (type);
7639             }
7640
7641           /* The qualifiers on the function type become the qualifiers on
7642              the non-static member function. */
7643           quals |= cp_type_quals (type);
7644         }
7645     }
7646
7647   /* If this is a type name (such as, in a cast or sizeof),
7648      compute the type and return it now.  */
7649
7650   if (decl_context == TYPENAME)
7651     {
7652       /* Note that the grammar rejects storage classes
7653          in typenames, fields or parameters.  */
7654       if (type_quals != TYPE_UNQUALIFIED)
7655         type_quals = TYPE_UNQUALIFIED;
7656
7657       /* Special case: "friend class foo" looks like a TYPENAME context.  */
7658       if (friendp)
7659         {
7660           if (type_quals != TYPE_UNQUALIFIED)
7661             {
7662               error ("type qualifiers specified for friend class declaration");
7663               type_quals = TYPE_UNQUALIFIED;
7664             }
7665           if (inlinep)
7666             {
7667               error ("%<inline%> specified for friend class declaration");
7668               inlinep = 0;
7669             }
7670
7671           if (!current_aggr)
7672             {
7673               /* Don't allow friend declaration without a class-key.  */
7674               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
7675                 pedwarn ("template parameters cannot be friends");
7676               else if (TREE_CODE (type) == TYPENAME_TYPE)
7677                 pedwarn ("friend declaration requires class-key, "
7678                          "i.e. %<friend class %T::%D%>",
7679                          TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
7680               else
7681                 pedwarn ("friend declaration requires class-key, "
7682                          "i.e. %<friend %#T%>",
7683                          type);
7684             }
7685
7686           /* Only try to do this stuff if we didn't already give up.  */
7687           if (type != integer_type_node)
7688             {
7689               /* A friendly class?  */
7690               if (current_class_type)
7691                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
7692                                    /*complain=*/true);
7693               else
7694                 error ("trying to make class %qT a friend of global scope",
7695                        type);
7696
7697               type = void_type_node;
7698             }
7699         }
7700       else if (quals)
7701         {
7702           if (ctype == NULL_TREE)
7703             {
7704               if (TREE_CODE (type) != METHOD_TYPE)
7705                 error ("invalid qualifiers on non-member function type");
7706               else
7707                 ctype = TYPE_METHOD_BASETYPE (type);
7708             }
7709           if (ctype)
7710             {
7711               tree dummy = build_decl (TYPE_DECL, unqualified_id, type);
7712               grok_method_quals (ctype, dummy, quals);
7713               type = TREE_TYPE (dummy);
7714             }
7715         }
7716
7717       return type;
7718     }
7719   else if (unqualified_id == NULL_TREE && decl_context != PARM
7720            && decl_context != CATCHPARM
7721            && TREE_CODE (type) != UNION_TYPE
7722            && ! bitfield)
7723     {
7724       error ("abstract declarator %qT used as declaration", type);
7725       return error_mark_node;
7726     }
7727
7728   /* Only functions may be declared using an operator-function-id.  */
7729   if (unqualified_id
7730       && IDENTIFIER_OPNAME_P (unqualified_id)
7731       && TREE_CODE (type) != FUNCTION_TYPE
7732       && TREE_CODE (type) != METHOD_TYPE)
7733     {
7734       error ("declaration of %qD as non-function", unqualified_id);
7735       return error_mark_node;
7736     }
7737
7738   /* We don't check parameter types here because we can emit a better
7739      error message later.  */
7740   if (decl_context != PARM)
7741     type = check_var_type (unqualified_id, type);
7742
7743   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
7744      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
7745
7746   if (decl_context == PARM || decl_context == CATCHPARM)
7747     {
7748       if (ctype || in_namespace)
7749         error ("cannot use %<::%> in parameter declaration");
7750
7751       /* A parameter declared as an array of T is really a pointer to T.
7752          One declared as a function is really a pointer to a function.
7753          One declared as a member is really a pointer to member.  */
7754
7755       if (TREE_CODE (type) == ARRAY_TYPE)
7756         {
7757           /* Transfer const-ness of array into that of type pointed to.  */
7758           type = build_pointer_type (TREE_TYPE (type));
7759           type_quals = TYPE_UNQUALIFIED;
7760         }
7761       else if (TREE_CODE (type) == FUNCTION_TYPE)
7762         type = build_pointer_type (type);
7763     }
7764
7765   {
7766     tree decl;
7767
7768     if (decl_context == PARM)
7769       {
7770         decl = cp_build_parm_decl (unqualified_id, type);
7771
7772         bad_specifiers (decl, "parameter", virtualp, quals != TYPE_UNQUALIFIED,
7773                         inlinep, friendp, raises != NULL_TREE);
7774       }
7775     else if (decl_context == FIELD)
7776       {
7777         /* The C99 flexible array extension.  */
7778         if (!staticp && TREE_CODE (type) == ARRAY_TYPE
7779             && TYPE_DOMAIN (type) == NULL_TREE)
7780           {
7781             tree itype = compute_array_index_type (dname, integer_zero_node);
7782             type = build_cplus_array_type (TREE_TYPE (type), itype);
7783           }
7784
7785         if (type == error_mark_node)
7786           {
7787             /* Happens when declaring arrays of sizes which
7788                are error_mark_node, for example.  */
7789             decl = NULL_TREE;
7790           }
7791         else if (in_namespace && !friendp)
7792           {
7793             /* Something like struct S { int N::j; };  */
7794             error ("invalid use of %<::%>");
7795             decl = NULL_TREE;
7796           }
7797         else if (TREE_CODE (type) == FUNCTION_TYPE)
7798           {
7799             int publicp = 0;
7800             tree function_context;
7801
7802             if (friendp == 0)
7803               {
7804                 if (ctype == NULL_TREE)
7805                   ctype = current_class_type;
7806
7807                 if (ctype == NULL_TREE)
7808                   {
7809                     error ("can't make %qD into a method -- not in a class",
7810                            unqualified_id);
7811                     return void_type_node;
7812                   }
7813
7814                 /* ``A union may [ ... ] not [ have ] virtual functions.''
7815                    ARM 9.5 */
7816                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
7817                   {
7818                     error ("function %qD declared virtual inside a union",
7819                            unqualified_id);
7820                     return void_type_node;
7821                   }
7822
7823                 if (NEW_DELETE_OPNAME_P (unqualified_id))
7824                   {
7825                     if (virtualp)
7826                       {
7827                         error ("%qD cannot be declared virtual, since it "
7828                                "is always static",
7829                                unqualified_id);
7830                         virtualp = 0;
7831                       }
7832                   }
7833                 else if (staticp < 2)
7834                   type = build_method_type_directly (ctype,
7835                                                      TREE_TYPE (type),
7836                                                      TYPE_ARG_TYPES (type));
7837               }
7838
7839             /* Check that the name used for a destructor makes sense.  */
7840             if (sfk == sfk_destructor
7841                 && !same_type_p (TREE_OPERAND
7842                                  (id_declarator->u.id.unqualified_name, 0),
7843                                  ctype))
7844               {
7845                 error ("declaration of %qD as member of %qT",
7846                        id_declarator->u.id.unqualified_name,
7847                        ctype);
7848                 return error_mark_node;
7849               }
7850
7851             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
7852             function_context = (ctype != NULL_TREE) ?
7853               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
7854             publicp = (! friendp || ! staticp)
7855               && function_context == NULL_TREE;
7856             decl = grokfndecl (ctype, type,
7857                                TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7858                                ? unqualified_id : dname,
7859                                parms,
7860                                unqualified_id,
7861                                virtualp, flags, quals, raises,
7862                                friendp ? -1 : 0, friendp, publicp, inlinep,
7863                                sfk,
7864                                funcdef_flag, template_count, in_namespace, attrlist);
7865             if (decl == NULL_TREE)
7866               return decl;
7867 #if 0
7868             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
7869             /* The decl and setting of decl_attr is also turned off.  */
7870             decl = build_decl_attribute_variant (decl, decl_attr);
7871 #endif
7872
7873             /* [class.conv.ctor]
7874
7875                A constructor declared without the function-specifier
7876                explicit that can be called with a single parameter
7877                specifies a conversion from the type of its first
7878                parameter to the type of its class.  Such a constructor
7879                is called a converting constructor.  */
7880             if (explicitp == 2)
7881               DECL_NONCONVERTING_P (decl) = 1;
7882             else if (DECL_CONSTRUCTOR_P (decl))
7883               {
7884                 /* The constructor can be called with exactly one
7885                    parameter if there is at least one parameter, and
7886                    any subsequent parameters have default arguments.
7887                    Ignore any compiler-added parms.  */
7888                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
7889
7890                 if (arg_types == void_list_node
7891                     || (arg_types
7892                         && TREE_CHAIN (arg_types)
7893                         && TREE_CHAIN (arg_types) != void_list_node
7894                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
7895                   DECL_NONCONVERTING_P (decl) = 1;
7896               }
7897           }
7898         else if (TREE_CODE (type) == METHOD_TYPE)
7899           {
7900             /* We only get here for friend declarations of
7901                members of other classes.  */
7902             /* All method decls are public, so tell grokfndecl to set
7903                TREE_PUBLIC, also.  */
7904             decl = grokfndecl (ctype, type,
7905                                TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7906                                ? unqualified_id : dname,
7907                                parms,
7908                                unqualified_id,
7909                                virtualp, flags, quals, raises,
7910                                friendp ? -1 : 0, friendp, 1, 0, sfk,
7911                                funcdef_flag, template_count, in_namespace,
7912                                attrlist);
7913             if (decl == NULL_TREE)
7914               return NULL_TREE;
7915           }
7916         else if (!staticp && !dependent_type_p (type)
7917                  && !COMPLETE_TYPE_P (complete_type (type))
7918                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
7919           {
7920             if (unqualified_id)
7921               error ("field %qD has incomplete type", unqualified_id);
7922             else
7923               error ("name %qT has incomplete type", type);
7924
7925             /* If we're instantiating a template, tell them which
7926                instantiation made the field's type be incomplete.  */
7927             if (current_class_type
7928                 && TYPE_NAME (current_class_type)
7929                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
7930                 && declspecs->type
7931                 && declspecs->type == type)
7932               error ("  in instantiation of template %qT",
7933                      current_class_type);
7934
7935             type = error_mark_node;
7936             decl = NULL_TREE;
7937           }
7938         else
7939           {
7940             if (friendp)
7941               {
7942                 error ("%qE is neither function nor member function; "
7943                        "cannot be declared friend", unqualified_id);
7944                 friendp = 0;
7945               }
7946             decl = NULL_TREE;
7947           }
7948
7949         if (friendp)
7950           {
7951             /* Friends are treated specially.  */
7952             if (ctype == current_class_type)
7953               warning ("member functions are implicitly friends of their class");
7954             else if (decl && DECL_NAME (decl))
7955               {
7956                 if (template_class_depth (current_class_type) == 0)
7957                   {
7958                     decl = check_explicit_specialization
7959                       (unqualified_id, decl, template_count,
7960                        2 * (funcdef_flag != 0) + 4);
7961                     if (decl == error_mark_node)
7962                       return error_mark_node;
7963                   }
7964
7965                 decl = do_friend (ctype, unqualified_id, decl,
7966                                   *attrlist, flags, quals, funcdef_flag);
7967                 return decl;
7968               }
7969             else
7970               return void_type_node;
7971           }
7972
7973         /* Structure field.  It may not be a function, except for C++.  */
7974
7975         if (decl == NULL_TREE)
7976           {
7977             if (initialized)
7978               {
7979                 if (!staticp)
7980                   {
7981                     /* An attempt is being made to initialize a non-static
7982                        member.  But, from [class.mem]:
7983
7984                        4 A member-declarator can contain a
7985                        constant-initializer only if it declares a static
7986                        member (_class.static_) of integral or enumeration
7987                        type, see _class.static.data_.
7988
7989                        This used to be relatively common practice, but
7990                        the rest of the compiler does not correctly
7991                        handle the initialization unless the member is
7992                        static so we make it static below.  */
7993                     pedwarn ("ISO C++ forbids initialization of member %qD",
7994                              unqualified_id);
7995                     pedwarn ("making %qD static", unqualified_id);
7996                     staticp = 1;
7997                   }
7998
7999                 if (uses_template_parms (type))
8000                   /* We'll check at instantiation time.  */
8001                   ;
8002                 else if (check_static_variable_definition (unqualified_id,
8003                                                            type))
8004                   /* If we just return the declaration, crashes
8005                      will sometimes occur.  We therefore return
8006                      void_type_node, as if this was a friend
8007                      declaration, to cause callers to completely
8008                      ignore this declaration.  */
8009                   return void_type_node;
8010               }
8011
8012             if (staticp)
8013               {
8014                 /* C++ allows static class members.  All other work
8015                    for this is done by grokfield.  */
8016                 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
8017                 set_linkage_for_static_data_member (decl);
8018                 /* Even if there is an in-class initialization, DECL
8019                    is considered undefined until an out-of-class
8020                    definition is provided.  */
8021                 DECL_EXTERNAL (decl) = 1;
8022               }
8023             else
8024               {
8025                 decl = build_decl (FIELD_DECL, unqualified_id, type);
8026                 DECL_NONADDRESSABLE_P (decl) = bitfield;
8027                 if (storage_class == sc_mutable)
8028                   {
8029                     DECL_MUTABLE_P (decl) = 1;
8030                     storage_class = sc_none;
8031                   }
8032               }
8033
8034             bad_specifiers (decl, "field", virtualp, quals != TYPE_UNQUALIFIED,
8035                             inlinep, friendp, raises != NULL_TREE);
8036           }
8037       }
8038     else if (TREE_CODE (type) == FUNCTION_TYPE
8039              || TREE_CODE (type) == METHOD_TYPE)
8040       {
8041         tree original_name;
8042         int publicp = 0;
8043
8044         if (!unqualified_id)
8045           return NULL_TREE;
8046
8047         if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
8048           original_name = dname;
8049         else
8050           original_name = unqualified_id;
8051
8052         if (storage_class == sc_auto)
8053           error ("storage class %<auto%> invalid for function %qs", name);
8054         else if (storage_class == sc_register)
8055           error ("storage class %<register%> invalid for function %qs", name);
8056         else if (thread_p)
8057           error ("storage class %<__thread%> invalid for function %qs", name);
8058
8059         /* Function declaration not at top level.
8060            Storage classes other than `extern' are not allowed
8061            and `extern' makes no difference.  */
8062         if (! toplevel_bindings_p ()
8063             && (storage_class == sc_static
8064                 || declspecs->specs[(int)ds_inline])
8065             && pedantic)
8066           {
8067             if (storage_class == sc_static)
8068               pedwarn ("%<static%> specified invalid for function %qs "
8069                        "declared out of global scope", name);
8070             else
8071               pedwarn ("%<inline%> specifier invalid for function %qs "
8072                        "declared out of global scope", name);
8073           }
8074
8075         if (ctype == NULL_TREE)
8076           {
8077             if (virtualp)
8078               {
8079                 error ("virtual non-class function %qs", name);
8080                 virtualp = 0;
8081               }
8082           }
8083         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
8084                  && !NEW_DELETE_OPNAME_P (original_name))
8085           type = build_method_type_directly (ctype,
8086                                              TREE_TYPE (type),
8087                                              TYPE_ARG_TYPES (type));
8088
8089         /* Record presence of `static'.  */
8090         publicp = (ctype != NULL_TREE
8091                    || storage_class == sc_extern
8092                    || storage_class != sc_static);
8093
8094         decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
8095                            virtualp, flags, quals, raises,
8096                            1, friendp,
8097                            publicp, inlinep, sfk, funcdef_flag,
8098                            template_count, in_namespace, attrlist);
8099         if (decl == NULL_TREE)
8100           return NULL_TREE;
8101
8102         if (staticp == 1)
8103           {
8104             int invalid_static = 0;
8105
8106             /* Don't allow a static member function in a class, and forbid
8107                declaring main to be static.  */
8108             if (TREE_CODE (type) == METHOD_TYPE)
8109               {
8110                 pedwarn ("cannot declare member function %qD to have "
8111                          "static linkage", decl);
8112                 invalid_static = 1;
8113               }
8114             else if (current_function_decl)
8115               {
8116                 /* FIXME need arm citation */
8117                 error ("cannot declare static function inside another function");
8118                 invalid_static = 1;
8119               }
8120
8121             if (invalid_static)
8122               {
8123                 staticp = 0;
8124                 storage_class = sc_none;
8125               }
8126           }
8127       }
8128     else
8129       {
8130         /* It's a variable.  */
8131
8132         /* An uninitialized decl with `extern' is a reference.  */
8133         decl = grokvardecl (type, unqualified_id,
8134                             declspecs,
8135                             initialized,
8136                             (type_quals & TYPE_QUAL_CONST) != 0,
8137                             ctype ? ctype : in_namespace);
8138         bad_specifiers (decl, "variable", virtualp, quals != TYPE_UNQUALIFIED,
8139                         inlinep, friendp, raises != NULL_TREE);
8140
8141         if (ctype)
8142           {
8143             DECL_CONTEXT (decl) = ctype;
8144             if (staticp == 1)
8145               {
8146                 pedwarn ("%<static%> may not be used when defining "
8147                          "(as opposed to declaring) a static data member");
8148                 staticp = 0;
8149                 storage_class = sc_none;
8150               }
8151             if (storage_class == sc_register && TREE_STATIC (decl))
8152               {
8153                 error ("static member %qD declared %<register%>", decl);
8154                 storage_class = sc_none;
8155               }
8156             if (storage_class == sc_extern && pedantic)
8157               {
8158                 pedwarn ("cannot explicitly declare member %q#D to have "
8159                          "extern linkage",
8160                          decl);
8161                 storage_class = sc_none;
8162               }
8163           }
8164       }
8165
8166     /* Record `register' declaration for warnings on &
8167        and in case doing stupid register allocation.  */
8168
8169     if (storage_class == sc_register)
8170       DECL_REGISTER (decl) = 1;
8171     else if (storage_class == sc_extern)
8172       DECL_THIS_EXTERN (decl) = 1;
8173     else if (storage_class == sc_static)
8174       DECL_THIS_STATIC (decl) = 1;
8175
8176     /* Record constancy and volatility.  There's no need to do this
8177        when processing a template; we'll do this for the instantiated
8178        declaration based on the type of DECL.  */
8179     if (!processing_template_decl)
8180       cp_apply_type_quals_to_decl (type_quals, decl);
8181
8182     return decl;
8183   }
8184 }
8185 \f
8186 /* Subroutine of start_function.  Ensure that each of the parameter
8187    types (as listed in PARMS) is complete, as is required for a
8188    function definition.  */
8189
8190 static void
8191 require_complete_types_for_parms (tree parms)
8192 {
8193   for (; parms; parms = TREE_CHAIN (parms))
8194     {
8195       if (dependent_type_p (TREE_TYPE (parms)))
8196         continue;
8197       if (VOID_TYPE_P (TREE_TYPE (parms)))
8198         /* grokparms will have already issued an error.  */
8199         TREE_TYPE (parms) = error_mark_node;
8200       else if (complete_type_or_else (TREE_TYPE (parms), parms))
8201         {
8202           layout_decl (parms, 0);
8203           DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8204         }
8205     }
8206 }
8207
8208 /* Returns nonzero if T is a local variable.  */
8209
8210 int
8211 local_variable_p (tree t)
8212 {
8213   if ((TREE_CODE (t) == VAR_DECL
8214        /* A VAR_DECL with a context that is a _TYPE is a static data
8215           member.  */
8216        && !TYPE_P (CP_DECL_CONTEXT (t))
8217        /* Any other non-local variable must be at namespace scope.  */
8218        && !DECL_NAMESPACE_SCOPE_P (t))
8219       || (TREE_CODE (t) == PARM_DECL))
8220     return 1;
8221
8222   return 0;
8223 }
8224
8225 /* Returns nonzero if T is an automatic local variable or a label.
8226    (These are the declarations that need to be remapped when the code
8227    containing them is duplicated.)  */
8228
8229 int
8230 nonstatic_local_decl_p (tree t)
8231 {
8232   return ((local_variable_p (t) && !TREE_STATIC (t))
8233           || TREE_CODE (t) == LABEL_DECL
8234           || TREE_CODE (t) == RESULT_DECL);
8235 }
8236
8237 /* Like local_variable_p, but suitable for use as a tree-walking
8238    function.  */
8239
8240 static tree
8241 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
8242                          void *data ATTRIBUTE_UNUSED)
8243 {
8244   if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8245     return *tp;
8246   else if (TYPE_P (*tp))
8247     *walk_subtrees = 0;
8248
8249   return NULL_TREE;
8250 }
8251
8252
8253 /* Check that ARG, which is a default-argument expression for a
8254    parameter DECL, is valid.  Returns ARG, or ERROR_MARK_NODE, if
8255    something goes wrong.  DECL may also be a _TYPE node, rather than a
8256    DECL, if there is no DECL available.  */
8257
8258 tree
8259 check_default_argument (tree decl, tree arg)
8260 {
8261   tree var;
8262   tree decl_type;
8263
8264   if (TREE_CODE (arg) == DEFAULT_ARG)
8265     /* We get a DEFAULT_ARG when looking at an in-class declaration
8266        with a default argument.  Ignore the argument for now; we'll
8267        deal with it after the class is complete.  */
8268     return arg;
8269
8270   if (processing_template_decl || uses_template_parms (arg))
8271     /* We don't do anything checking until instantiation-time.  Note
8272        that there may be uninstantiated arguments even for an
8273        instantiated function, since default arguments are not
8274        instantiated until they are needed.  */
8275     return arg;
8276
8277   if (TYPE_P (decl))
8278     {
8279       decl_type = decl;
8280       decl = NULL_TREE;
8281     }
8282   else
8283     decl_type = TREE_TYPE (decl);
8284
8285   if (arg == error_mark_node
8286       || decl == error_mark_node
8287       || TREE_TYPE (arg) == error_mark_node
8288       || decl_type == error_mark_node)
8289     /* Something already went wrong.  There's no need to check
8290        further.  */
8291     return error_mark_node;
8292
8293   /* [dcl.fct.default]
8294
8295      A default argument expression is implicitly converted to the
8296      parameter type.  */
8297   if (!TREE_TYPE (arg)
8298       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
8299     {
8300       if (decl)
8301         error ("default argument for %q#D has type %qT",
8302                decl, TREE_TYPE (arg));
8303       else
8304         error ("default argument for parameter of type %qT has type %qT",
8305                decl_type, TREE_TYPE (arg));
8306
8307       return error_mark_node;
8308     }
8309
8310   /* [dcl.fct.default]
8311
8312      Local variables shall not be used in default argument
8313      expressions.
8314
8315      The keyword `this' shall not be used in a default argument of a
8316      member function.  */
8317   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8318                                       NULL);
8319   if (var)
8320     {
8321       error ("default argument %qE uses local variable %qD", arg, var);
8322       return error_mark_node;
8323     }
8324
8325   /* All is well.  */
8326   return arg;
8327 }
8328
8329 /* Decode the list of parameter types for a function type.
8330    Given the list of things declared inside the parens,
8331    return a list of types.
8332
8333    If this parameter does not end with an ellipsis, we append
8334    void_list_node.
8335
8336    *PARMS is set to the chain of PARM_DECLs created.  */
8337
8338 static tree
8339 grokparms (cp_parameter_declarator *first_parm, tree *parms)
8340 {
8341   tree result = NULL_TREE;
8342   tree decls = NULL_TREE;
8343   int ellipsis = !first_parm || first_parm->ellipsis_p;
8344   cp_parameter_declarator *parm;
8345   int any_error = 0;
8346
8347   for (parm = first_parm; parm != NULL; parm = parm->next)
8348     {
8349       tree type = NULL_TREE;
8350       tree init = parm->default_argument;
8351       tree attrs;
8352       tree decl;
8353
8354       if (parm == no_parameters)
8355         break;
8356
8357       attrs = parm->decl_specifiers.attributes;
8358       parm->decl_specifiers.attributes = NULL_TREE;
8359       decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
8360                              PARM, init != NULL_TREE, &attrs);
8361       if (! decl || TREE_TYPE (decl) == error_mark_node)
8362         continue;
8363
8364       if (attrs)
8365         cplus_decl_attributes (&decl, attrs, 0);
8366
8367       type = TREE_TYPE (decl);
8368       if (VOID_TYPE_P (type))
8369         {
8370           if (same_type_p (type, void_type_node)
8371               && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
8372             /* this is a parmlist of `(void)', which is ok.  */
8373             break;
8374           cxx_incomplete_type_error (decl, type);
8375           /* It's not a good idea to actually create parameters of
8376              type `void'; other parts of the compiler assume that a
8377              void type terminates the parameter list.  */
8378           type = error_mark_node;
8379           TREE_TYPE (decl) = error_mark_node;
8380         }
8381
8382       if (type != error_mark_node)
8383         {
8384           /* Top-level qualifiers on the parameters are
8385              ignored for function types.  */
8386           type = cp_build_qualified_type (type, 0);
8387           if (TREE_CODE (type) == METHOD_TYPE)
8388             {
8389               error ("parameter %qD invalidly declared method type", decl);
8390               type = build_pointer_type (type);
8391               TREE_TYPE (decl) = type;
8392             }
8393           else if (abstract_virtuals_error (decl, type))
8394             any_error = 1;  /* Seems like a good idea.  */
8395           else if (POINTER_TYPE_P (type))
8396             {
8397               /* [dcl.fct]/6, parameter types cannot contain pointers
8398                  (references) to arrays of unknown bound.  */
8399               tree t = TREE_TYPE (type);
8400               int ptr = TYPE_PTR_P (type);
8401
8402               while (1)
8403                 {
8404                   if (TYPE_PTR_P (t))
8405                     ptr = 1;
8406                   else if (TREE_CODE (t) != ARRAY_TYPE)
8407                     break;
8408                   else if (!TYPE_DOMAIN (t))
8409                     break;
8410                   t = TREE_TYPE (t);
8411                 }
8412               if (TREE_CODE (t) == ARRAY_TYPE)
8413                 error ("parameter %qD includes %s to array of unknown "
8414                        "bound %qT",
8415                        decl, ptr ? "pointer" : "reference", t);
8416             }
8417
8418           if (!any_error && init)
8419             init = check_default_argument (decl, init);
8420           else
8421             init = NULL_TREE;
8422         }
8423
8424       TREE_CHAIN (decl) = decls;
8425       decls = decl;
8426       result = tree_cons (init, type, result);
8427     }
8428   decls = nreverse (decls);
8429   result = nreverse (result);
8430   if (!ellipsis)
8431     result = chainon (result, void_list_node);
8432   *parms = decls;
8433
8434   return result;
8435 }
8436
8437 \f
8438 /* D is a constructor or overloaded `operator='.
8439
8440    Let T be the class in which D is declared. Then, this function
8441    returns:
8442
8443    -1 if D's is an ill-formed constructor or copy assignment operator
8444       whose first parameter is of type `T'.
8445    0  if D is not a copy constructor or copy assignment
8446       operator.
8447    1  if D is a copy constructor or copy assignment operator whose
8448       first parameter is a reference to const qualified T.
8449    2  if D is a copy constructor or copy assignment operator whose
8450       first parameter is a reference to non-const qualified T.
8451
8452    This function can be used as a predicate. Positive values indicate
8453    a copy constructor and nonzero values indicate a copy assignment
8454    operator.  */
8455
8456 int
8457 copy_fn_p (tree d)
8458 {
8459   tree args;
8460   tree arg_type;
8461   int result = 1;
8462
8463   gcc_assert (DECL_FUNCTION_MEMBER_P (d));
8464
8465   if (DECL_TEMPLATE_INFO (d)
8466       && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d)))
8467     /* Instantiations of template member functions are never copy
8468        functions.  Note that member functions of templated classes are
8469        represented as template functions internally, and we must
8470        accept those as copy functions.  */
8471     return 0;
8472
8473   args = FUNCTION_FIRST_USER_PARMTYPE (d);
8474   if (!args)
8475     return 0;
8476
8477   arg_type = TREE_VALUE (args);
8478
8479   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8480     {
8481       /* Pass by value copy assignment operator.  */
8482       result = -1;
8483     }
8484   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8485            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8486     {
8487       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8488         result = 2;
8489     }
8490   else
8491     return 0;
8492
8493   args = TREE_CHAIN (args);
8494
8495   if (args && args != void_list_node && !TREE_PURPOSE (args))
8496     /* There are more non-optional args.  */
8497     return 0;
8498
8499   return result;
8500 }
8501
8502 /* Remember any special properties of member function DECL.  */
8503
8504 void grok_special_member_properties (tree decl)
8505 {
8506   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
8507     ; /* Not special.  */
8508   else if (DECL_CONSTRUCTOR_P (decl))
8509     {
8510       int ctor = copy_fn_p (decl);
8511
8512       if (ctor > 0)
8513         {
8514           /* [class.copy]
8515
8516              A non-template constructor for class X is a copy
8517              constructor if its first parameter is of type X&, const
8518              X&, volatile X& or const volatile X&, and either there
8519              are no other parameters or else all other parameters have
8520              default arguments.  */
8521           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
8522           if (ctor > 1)
8523             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
8524         }
8525       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8526         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
8527     }
8528   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8529     {
8530       /* [class.copy]
8531
8532          A non-template assignment operator for class X is a copy
8533          assignment operator if its parameter is of type X, X&, const
8534          X&, volatile X& or const volatile X&.  */
8535
8536       int assop = copy_fn_p (decl);
8537
8538       if (assop)
8539         {
8540           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8541           if (assop != 1)
8542             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8543         }
8544     }
8545 }
8546
8547 /* Check a constructor DECL has the correct form.  Complains
8548    if the class has a constructor of the form X(X).  */
8549
8550 int
8551 grok_ctor_properties (tree ctype, tree decl)
8552 {
8553   int ctor_parm = copy_fn_p (decl);
8554
8555   if (ctor_parm < 0)
8556     {
8557       /* [class.copy]
8558
8559          A declaration of a constructor for a class X is ill-formed if
8560          its first parameter is of type (optionally cv-qualified) X
8561          and either there are no other parameters or else all other
8562          parameters have default arguments.
8563
8564          We *don't* complain about member template instantiations that
8565          have this form, though; they can occur as we try to decide
8566          what constructor to use during overload resolution.  Since
8567          overload resolution will never prefer such a constructor to
8568          the non-template copy constructor (which is either explicitly
8569          or implicitly defined), there's no need to worry about their
8570          existence.  Theoretically, they should never even be
8571          instantiated, but that's hard to forestall.  */
8572       error ("invalid constructor; you probably meant %<%T (const %T&)%>",
8573                 ctype, ctype);
8574       return 0;
8575     }
8576
8577   return 1;
8578 }
8579
8580 /* An operator with this code is unary, but can also be binary.  */
8581
8582 static int
8583 ambi_op_p (enum tree_code code)
8584 {
8585   return (code == INDIRECT_REF
8586           || code == ADDR_EXPR
8587           || code == CONVERT_EXPR
8588           || code == NEGATE_EXPR
8589           || code == PREINCREMENT_EXPR
8590           || code == PREDECREMENT_EXPR);
8591 }
8592
8593 /* An operator with this name can only be unary.  */
8594
8595 static int
8596 unary_op_p (enum tree_code code)
8597 {
8598   return (code == TRUTH_NOT_EXPR
8599           || code == BIT_NOT_EXPR
8600           || code == COMPONENT_REF
8601           || code == TYPE_EXPR);
8602 }
8603
8604 /* DECL is a declaration for an overloaded operator.  If COMPLAIN is true,
8605    errors are issued for invalid declarations.  */
8606
8607 void
8608 grok_op_properties (tree decl, int friendp, bool complain)
8609 {
8610   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8611   tree argtype;
8612   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
8613   tree name = DECL_NAME (decl);
8614   enum tree_code operator_code;
8615   int arity;
8616
8617   /* Count the number of arguments.  */
8618   for (argtype = argtypes, arity = 0;
8619        argtype && argtype != void_list_node;
8620        argtype = TREE_CHAIN (argtype))
8621     ++arity;
8622
8623   if (current_class_type == NULL_TREE)
8624     friendp = 1;
8625
8626   if (DECL_CONV_FN_P (decl))
8627     operator_code = TYPE_EXPR;
8628   else
8629     do
8630       {
8631 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
8632         if (ansi_opname (CODE) == name)                         \
8633           {                                                     \
8634             operator_code = (CODE);                             \
8635             break;                                              \
8636           }                                                     \
8637         else if (ansi_assopname (CODE) == name)                 \
8638           {                                                     \
8639             operator_code = (CODE);                             \
8640             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
8641             break;                                              \
8642           }
8643
8644 #include "operators.def"
8645 #undef DEF_OPERATOR
8646
8647         gcc_unreachable ();
8648       }
8649     while (0);
8650   gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
8651   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8652
8653   if (! friendp)
8654     {
8655       switch (operator_code)
8656         {
8657         case NEW_EXPR:
8658           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
8659           break;
8660
8661         case DELETE_EXPR:
8662           TYPE_GETS_DELETE (current_class_type) |= 1;
8663           break;
8664
8665         case VEC_NEW_EXPR:
8666           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
8667           break;
8668
8669         case VEC_DELETE_EXPR:
8670           TYPE_GETS_DELETE (current_class_type) |= 2;
8671           break;
8672
8673         default:
8674           break;
8675         }
8676     }
8677
8678     /* [basic.std.dynamic.allocation]/1:
8679
8680        A program is ill-formed if an allocation function is declared
8681        in a namespace scope other than global scope or declared static
8682        in global scope.
8683
8684        The same also holds true for deallocation functions.  */
8685   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
8686       || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8687     {
8688       if (DECL_NAMESPACE_SCOPE_P (decl))
8689         {
8690           if (CP_DECL_CONTEXT (decl) != global_namespace)
8691             error ("%qD may not be declared within a namespace", decl);
8692           else if (!TREE_PUBLIC (decl))
8693             error ("%qD may not be declared as static", decl);
8694         }
8695     }
8696
8697   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
8698     TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
8699   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8700     TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
8701   else
8702     {
8703       /* An operator function must either be a non-static member function
8704          or have at least one parameter of a class, a reference to a class,
8705          an enumeration, or a reference to an enumeration.  13.4.0.6 */
8706       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8707         {
8708           if (operator_code == TYPE_EXPR
8709               || operator_code == CALL_EXPR
8710               || operator_code == COMPONENT_REF
8711               || operator_code == ARRAY_REF
8712               || operator_code == NOP_EXPR)
8713             {
8714               error ("%qD must be a nonstatic member function", decl);
8715               return;
8716             }
8717           else
8718             {
8719               tree p;
8720
8721               if (DECL_STATIC_FUNCTION_P (decl))
8722                 {
8723                   error ("%qD must be either a non-static member "
8724                          "function or a non-member function", decl);
8725                   return;
8726                 }
8727
8728               for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
8729                 {
8730                   tree arg = non_reference (TREE_VALUE (p));
8731                   /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
8732                      because these checks are performed even on
8733                      template functions.  */
8734                   if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
8735                     break;
8736                 }
8737
8738               if (!p || p == void_list_node)
8739                 {
8740                   if (!complain)
8741                     return;
8742
8743                   error ("%qD must have an argument of class or "
8744                          "enumerated type",
8745                          decl);
8746                 }
8747             }
8748         }
8749
8750       /* There are no restrictions on the arguments to an overloaded
8751          "operator ()".  */
8752       if (operator_code == CALL_EXPR)
8753         return;
8754
8755       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
8756         {
8757           tree t = TREE_TYPE (name);
8758           if (! friendp)
8759             {
8760               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
8761               const char *what = 0;
8762
8763               if (ref)
8764                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
8765
8766               if (TREE_CODE (t) == VOID_TYPE)
8767                 what = "void";
8768               else if (t == current_class_type)
8769                 what = "the same type";
8770               /* Don't force t to be complete here.  */
8771               else if (IS_AGGR_TYPE (t)
8772                        && COMPLETE_TYPE_P (t)
8773                        && DERIVED_FROM_P (t, current_class_type))
8774                 what = "a base class";
8775
8776               if (what && warn_conversion)
8777                 warning ("conversion to %s%s will never use a type "
8778                          "conversion operator",
8779                          ref ? "a reference to " : "", what);
8780             }
8781         }
8782       if (operator_code == COND_EXPR)
8783         {
8784           /* 13.4.0.3 */
8785           error ("ISO C++ prohibits overloading operator ?:");
8786         }
8787       else if (ambi_op_p (operator_code))
8788         {
8789           if (arity == 1)
8790             /* We pick the one-argument operator codes by default, so
8791                we don't have to change anything.  */
8792             ;
8793           else if (arity == 2)
8794             {
8795               /* If we thought this was a unary operator, we now know
8796                  it to be a binary operator.  */
8797               switch (operator_code)
8798                 {
8799                 case INDIRECT_REF:
8800                   operator_code = MULT_EXPR;
8801                   break;
8802
8803                 case ADDR_EXPR:
8804                   operator_code = BIT_AND_EXPR;
8805                   break;
8806
8807                 case CONVERT_EXPR:
8808                   operator_code = PLUS_EXPR;
8809                   break;
8810
8811                 case NEGATE_EXPR:
8812                   operator_code = MINUS_EXPR;
8813                   break;
8814
8815                 case PREINCREMENT_EXPR:
8816                   operator_code = POSTINCREMENT_EXPR;
8817                   break;
8818
8819                 case PREDECREMENT_EXPR:
8820                   operator_code = POSTDECREMENT_EXPR;
8821                   break;
8822
8823                 default:
8824                   gcc_unreachable ();
8825                 }
8826
8827               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8828
8829               if ((operator_code == POSTINCREMENT_EXPR
8830                    || operator_code == POSTDECREMENT_EXPR)
8831                   && ! processing_template_decl
8832                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
8833                 {
8834                   if (methodp)
8835                     error ("postfix %qD must take %<int%> as its argument",
8836                               decl);
8837                   else
8838                     error
8839                       ("postfix %qD must take %<int%> as its second argument",
8840                        decl);
8841                 }
8842             }
8843           else
8844             {
8845               if (methodp)
8846                 error ("%qD must take either zero or one argument", decl);
8847               else
8848                 error ("%qD must take either one or two arguments", decl);
8849             }
8850
8851           /* More Effective C++ rule 6.  */
8852           if (warn_ecpp
8853               && (operator_code == POSTINCREMENT_EXPR
8854                   || operator_code == POSTDECREMENT_EXPR
8855                   || operator_code == PREINCREMENT_EXPR
8856                   || operator_code == PREDECREMENT_EXPR))
8857             {
8858               tree arg = TREE_VALUE (argtypes);
8859               tree ret = TREE_TYPE (TREE_TYPE (decl));
8860               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
8861                 arg = TREE_TYPE (arg);
8862               arg = TYPE_MAIN_VARIANT (arg);
8863               if (operator_code == PREINCREMENT_EXPR
8864                   || operator_code == PREDECREMENT_EXPR)
8865                 {
8866                   if (TREE_CODE (ret) != REFERENCE_TYPE
8867                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
8868                                        arg))
8869                     warning ("prefix %qD should return %qT", decl,
8870                              build_reference_type (arg));
8871                 }
8872               else
8873                 {
8874                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
8875                     warning ("postfix %qD should return %qT", decl, arg);
8876                 }
8877             }
8878         }
8879       else if (unary_op_p (operator_code))
8880         {
8881           if (arity != 1)
8882             {
8883               if (methodp)
8884                 error ("%qD must take %<void%>", decl);
8885               else
8886                 error ("%qD must take exactly one argument", decl);
8887             }
8888         }
8889       else /* if (binary_op_p (operator_code)) */
8890         {
8891           if (arity != 2)
8892             {
8893               if (methodp)
8894                 error ("%qD must take exactly one argument", decl);
8895               else
8896                 error ("%qD must take exactly two arguments", decl);
8897             }
8898
8899           /* More Effective C++ rule 7.  */
8900           if (warn_ecpp
8901               && (operator_code == TRUTH_ANDIF_EXPR
8902                   || operator_code == TRUTH_ORIF_EXPR
8903                   || operator_code == COMPOUND_EXPR))
8904             warning ("user-defined %qD always evaluates both arguments",
8905                      decl);
8906         }
8907
8908       /* Effective C++ rule 23.  */
8909       if (warn_ecpp
8910           && arity == 2
8911           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
8912           && (operator_code == PLUS_EXPR
8913               || operator_code == MINUS_EXPR
8914               || operator_code == TRUNC_DIV_EXPR
8915               || operator_code == MULT_EXPR
8916               || operator_code == TRUNC_MOD_EXPR)
8917           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
8918         warning ("%qD should return by value", decl);
8919
8920       /* [over.oper]/8 */
8921       for (; argtypes && argtypes != void_list_node;
8922           argtypes = TREE_CHAIN (argtypes))
8923         if (TREE_PURPOSE (argtypes))
8924           {
8925             TREE_PURPOSE (argtypes) = NULL_TREE;
8926             if (operator_code == POSTINCREMENT_EXPR
8927                 || operator_code == POSTDECREMENT_EXPR)
8928               {
8929                 if (pedantic)
8930                   pedwarn ("%qD cannot have default arguments", decl);
8931               }
8932             else
8933               error ("%qD cannot have default arguments", decl);
8934           }
8935
8936     }
8937
8938 }
8939 \f
8940 /* Return a string giving the keyword associate with CODE.  */
8941
8942 static const char *
8943 tag_name (enum tag_types code)
8944 {
8945   switch (code)
8946     {
8947     case record_type:
8948       return "struct";
8949     case class_type:
8950       return "class";
8951     case union_type:
8952       return "union";
8953     case enum_type:
8954       return "enum";
8955     case typename_type:
8956       return "typename";
8957     default:
8958       gcc_unreachable ();
8959     }
8960 }
8961
8962 /* Name lookup in an elaborated-type-specifier (after the keyword
8963    indicated by TAG_CODE) has found the TYPE_DECL DECL.  If the
8964    elaborated-type-specifier is invalid, issue a diagnostic and return
8965    error_mark_node; otherwise, return the *_TYPE to which it referred.
8966    If ALLOW_TEMPLATE_P is true, TYPE may be a class template.  */
8967
8968 tree
8969 check_elaborated_type_specifier (enum tag_types tag_code,
8970                                  tree decl,
8971                                  bool allow_template_p)
8972 {
8973   tree type;
8974
8975   /* In the case of:
8976
8977        struct S { struct S *p; };
8978
8979      name lookup will find the TYPE_DECL for the implicit "S::S"
8980      typedef.  Adjust for that here.  */
8981   if (DECL_SELF_REFERENCE_P (decl))
8982     decl = TYPE_NAME (TREE_TYPE (decl));
8983
8984   type = TREE_TYPE (decl);
8985
8986   /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
8987      is false for this case as well.  */
8988   if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8989     {
8990       error ("using template type parameter %qT after %qs",
8991              type, tag_name (tag_code));
8992       return error_mark_node;
8993     }
8994   /*   [dcl.type.elab]
8995
8996        If the identifier resolves to a typedef-name or a template
8997        type-parameter, the elaborated-type-specifier is ill-formed.
8998
8999      In other words, the only legitimate declaration to use in the
9000      elaborated type specifier is the implicit typedef created when
9001      the type is declared.  */
9002   else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
9003            && tag_code != typename_type)
9004     {
9005       error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
9006       cp_error_at ("%qD has a previous declaration here", decl);
9007       return error_mark_node;
9008     }
9009   else if (TREE_CODE (type) != RECORD_TYPE
9010            && TREE_CODE (type) != UNION_TYPE
9011            && tag_code != enum_type
9012            && tag_code != typename_type)
9013     {
9014       error ("%qT referred to as %qs", type, tag_name (tag_code));
9015       cp_error_at ("%qT has a previous declaration here", type);
9016       return error_mark_node;
9017     }
9018   else if (TREE_CODE (type) != ENUMERAL_TYPE
9019            && tag_code == enum_type
9020            && tag_code != typename_type)
9021     {
9022       error ("%qT referred to as enum", type);
9023       cp_error_at ("%qT has a previous declaration here", type);
9024       return error_mark_node;
9025     }
9026   else if (!allow_template_p
9027            && TREE_CODE (type) == RECORD_TYPE
9028            && CLASSTYPE_IS_TEMPLATE (type))
9029     {
9030       /* If a class template appears as elaborated type specifier
9031          without a template header such as:
9032
9033            template <class T> class C {};
9034            void f(class C);             // No template header here
9035
9036          then the required template argument is missing.  */
9037       error ("template argument required for %<%s %T%>",
9038              tag_name (tag_code),
9039              DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
9040       return error_mark_node;
9041     }
9042
9043   return type;
9044 }
9045
9046 /* Lookup NAME in elaborate type specifier in scope according to
9047    SCOPE and issue diagnostics if necessary.
9048    Return *_TYPE node upon success, NULL_TREE when the NAME is not
9049    found, and ERROR_MARK_NODE for type error.  */
9050
9051 static tree
9052 lookup_and_check_tag (enum tag_types tag_code, tree name,
9053                       tag_scope scope, bool template_header_p)
9054 {
9055   tree t;
9056   tree decl;
9057   if (scope == ts_global)
9058     {
9059       /* First try ordinary name lookup, ignoring hidden class name
9060          injected via friend declaration.  */
9061       decl = lookup_name (name, 2);
9062       /* If that fails, the name will be placed in the smallest
9063          non-class, non-function-prototype scope according to 3.3.1/5.
9064          We may already have a hidden name declared as friend in this
9065          scope.  So lookup again but not ignoring hidden name.
9066          If we find one, that name will be made visible rather than
9067          creating a new tag.  */
9068       if (!decl)
9069         decl = lookup_type_scope (name, ts_within_enclosing_non_class);
9070     }
9071   else
9072     decl = lookup_type_scope (name, scope);
9073
9074   if (decl && DECL_CLASS_TEMPLATE_P (decl))
9075     decl = DECL_TEMPLATE_RESULT (decl);
9076
9077   if (decl && TREE_CODE (decl) == TYPE_DECL)
9078     {
9079       /* Look for invalid nested type:
9080            class C {
9081              class C {};
9082            };  */
9083       if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
9084         {
9085           error ("%qD has the same name as the class in which it is "
9086                  "declared",
9087                  decl);
9088           return error_mark_node;
9089         }
9090
9091       /* Two cases we need to consider when deciding if a class
9092          template is allowed as an elaborated type specifier:
9093          1. It is a self reference to its own class.
9094          2. It comes with a template header.
9095
9096          For example:
9097
9098            template <class T> class C {
9099              class C *c1;               // DECL_SELF_REFERENCE_P is true
9100              class D;
9101            };
9102            template <class U> class C; // template_header_p is true
9103            template <class T> class C<T>::D {
9104              class C *c2;               // DECL_SELF_REFERENCE_P is true
9105            };  */
9106
9107       t = check_elaborated_type_specifier (tag_code,
9108                                            decl,
9109                                            template_header_p
9110                                            | DECL_SELF_REFERENCE_P (decl));
9111       return t;
9112     }
9113   else
9114     return NULL_TREE;
9115 }
9116
9117 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
9118    Define the tag as a forward-reference if it is not defined.
9119
9120    If a declaration is given, process it here, and report an error if
9121    multiple declarations are not identical.
9122
9123    SCOPE is TS_CURRENT when this is also a definition.  Only look in
9124    the current frame for the name (since C++ allows new names in any
9125    scope.)  It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
9126    declaration.  Only look beginning from the current scope outward up
9127    till the nearest non-class scope.  Otherwise it is TS_GLOBAL.
9128
9129    TEMPLATE_HEADER_P is true when this declaration is preceded by
9130    a set of template parameters.  */
9131
9132 tree
9133 xref_tag (enum tag_types tag_code, tree name,
9134           tag_scope scope, bool template_header_p)
9135 {
9136   enum tree_code code;
9137   tree t;
9138   tree context = NULL_TREE;
9139
9140   timevar_push (TV_NAME_LOOKUP);
9141
9142   gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9143
9144   switch (tag_code)
9145     {
9146     case record_type:
9147     case class_type:
9148       code = RECORD_TYPE;
9149       break;
9150     case union_type:
9151       code = UNION_TYPE;
9152       break;
9153     case enum_type:
9154       code = ENUMERAL_TYPE;
9155       break;
9156     default:
9157       gcc_unreachable ();
9158     }
9159
9160   /* In case of anonymous name, xref_tag is only called to
9161      make type node and push name.  Name lookup is not required.  */
9162   if (ANON_AGGRNAME_P (name))
9163     t = NULL_TREE;
9164   else
9165     t = lookup_and_check_tag  (tag_code, name,
9166                                scope, template_header_p);
9167
9168   if (t == error_mark_node)
9169     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9170
9171   if (scope != ts_current && t && current_class_type
9172       && template_class_depth (current_class_type)
9173       && template_header_p)
9174     {
9175       /* Since SCOPE is not TS_CURRENT, we are not looking at a
9176          definition of this tag.  Since, in addition, we are currently
9177          processing a (member) template declaration of a template
9178          class, we must be very careful; consider:
9179
9180            template <class X>
9181            struct S1
9182
9183            template <class U>
9184            struct S2
9185            { template <class V>
9186            friend struct S1; };
9187
9188          Here, the S2::S1 declaration should not be confused with the
9189          outer declaration.  In particular, the inner version should
9190          have a template parameter of level 2, not level 1.  This
9191          would be particularly important if the member declaration
9192          were instead:
9193
9194            template <class V = U> friend struct S1;
9195
9196          say, when we should tsubst into `U' when instantiating
9197          S2.  On the other hand, when presented with:
9198
9199            template <class T>
9200            struct S1 {
9201              template <class U>
9202              struct S2 {};
9203              template <class U>
9204              friend struct S2;
9205            };
9206
9207          we must find the inner binding eventually.  We
9208          accomplish this by making sure that the new type we
9209          create to represent this declaration has the right
9210          TYPE_CONTEXT.  */
9211       context = TYPE_CONTEXT (t);
9212       t = NULL_TREE;
9213     }
9214
9215   if (! t)
9216     {
9217       /* If no such tag is yet defined, create a forward-reference node
9218          and record it as the "definition".
9219          When a real declaration of this type is found,
9220          the forward-reference will be altered into a real type.  */
9221       if (code == ENUMERAL_TYPE)
9222         {
9223           error ("use of enum %q#D without previous declaration", name);
9224           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9225         }
9226       else
9227         {
9228           t = make_aggr_type (code);
9229           TYPE_CONTEXT (t) = context;
9230           t = pushtag (name, t, scope);
9231         }
9232     }
9233   else
9234     {
9235       if (template_header_p && IS_AGGR_TYPE (t))
9236         redeclare_class_template (t, current_template_parms);
9237       else if (!processing_template_decl
9238                && CLASS_TYPE_P (t)
9239                && CLASSTYPE_IS_TEMPLATE (t))
9240         {
9241           error ("redeclaration of %qT as a non-template", t);
9242           t = error_mark_node;
9243         }
9244
9245       /* Make injected friend class visible.  */
9246       if (scope != ts_within_enclosing_non_class
9247           && hidden_name_p (TYPE_NAME (t)))
9248         {
9249           DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
9250           DECL_FRIEND_P (TYPE_NAME (t)) = 0;
9251
9252           if (TYPE_TEMPLATE_INFO (t))
9253             {
9254               DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
9255               DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
9256             }
9257         }
9258     }
9259
9260   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9261 }
9262
9263 tree
9264 xref_tag_from_type (tree old, tree id, tag_scope scope)
9265 {
9266   enum tag_types tag_kind;
9267
9268   if (TREE_CODE (old) == RECORD_TYPE)
9269     tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9270   else
9271     tag_kind  = union_type;
9272
9273   if (id == NULL_TREE)
9274     id = TYPE_IDENTIFIER (old);
9275
9276   return xref_tag (tag_kind, id, scope, false);
9277 }
9278
9279 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9280    BASE_LIST.  For each element on BASE_LIST the TREE_PURPOSE is an
9281    access_* node, and the TREE_VALUE is the type of the base-class.
9282    Non-NULL TREE_TYPE indicates virtual inheritance.  */
9283
9284 void
9285 xref_basetypes (tree ref, tree base_list)
9286 {
9287   tree *basep;
9288   tree binfo, base_binfo;
9289   unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases.  */
9290   unsigned max_bases = 0;  /* Maximum direct bases.  */
9291   int i;
9292   tree default_access;
9293   tree igo_prev; /* Track Inheritance Graph Order.  */
9294
9295   if (ref == error_mark_node)
9296     return;
9297
9298   /* The base of a derived class is private by default, all others are
9299      public.  */
9300   default_access = (TREE_CODE (ref) == RECORD_TYPE
9301                     && CLASSTYPE_DECLARED_CLASS (ref)
9302                     ? access_private_node : access_public_node);
9303
9304   /* First, make sure that any templates in base-classes are
9305      instantiated.  This ensures that if we call ourselves recursively
9306      we do not get confused about which classes are marked and which
9307      are not.  */
9308   basep = &base_list;
9309   while (*basep)
9310     {
9311       tree basetype = TREE_VALUE (*basep);
9312
9313       if (!(processing_template_decl && uses_template_parms (basetype))
9314           && !complete_type_or_else (basetype, NULL))
9315         /* An incomplete type.  Remove it from the list.  */
9316         *basep = TREE_CHAIN (*basep);
9317       else
9318         {
9319           max_bases++;
9320           if (TREE_TYPE (*basep))
9321             max_vbases++;
9322           if (CLASS_TYPE_P (basetype))
9323             max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
9324           basep = &TREE_CHAIN (*basep);
9325         }
9326     }
9327
9328   TYPE_MARKED_P (ref) = 1;
9329
9330   /* The binfo slot should be empty, unless this is an (ill-formed)
9331      redefinition.  */
9332   gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
9333   gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
9334
9335   binfo = make_tree_binfo (max_bases);
9336
9337   TYPE_BINFO (ref) = binfo;
9338   BINFO_OFFSET (binfo) = size_zero_node;
9339   BINFO_TYPE (binfo) = ref;
9340
9341   if (max_bases)
9342     {
9343       BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, max_bases);
9344       /* An aggregate cannot have baseclasses.  */
9345       CLASSTYPE_NON_AGGREGATE (ref) = 1;
9346
9347       if (TREE_CODE (ref) == UNION_TYPE)
9348         error ("derived union %qT invalid", ref);
9349     }
9350
9351   if (max_bases > 1)
9352     {
9353       if (TYPE_FOR_JAVA (ref))
9354         error ("Java class %qT cannot have multiple bases", ref);
9355     }
9356
9357   if (max_vbases)
9358     {
9359       CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, max_vbases);
9360
9361       if (TYPE_FOR_JAVA (ref))
9362         error ("Java class %qT cannot have virtual bases", ref);
9363     }
9364
9365   for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
9366     {
9367       tree access = TREE_PURPOSE (base_list);
9368       int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
9369       tree basetype = TREE_VALUE (base_list);
9370
9371       if (access == access_default_node)
9372         access = default_access;
9373
9374       if (TREE_CODE (basetype) == TYPE_DECL)
9375         basetype = TREE_TYPE (basetype);
9376       if (TREE_CODE (basetype) != RECORD_TYPE
9377           && TREE_CODE (basetype) != TYPENAME_TYPE
9378           && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9379           && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
9380         {
9381           error ("base type %qT fails to be a struct or class type",
9382                  basetype);
9383           continue;
9384         }
9385
9386       if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
9387         TYPE_FOR_JAVA (ref) = 1;
9388
9389       base_binfo = NULL_TREE;
9390       if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
9391         {
9392           base_binfo = TYPE_BINFO (basetype);
9393           /* The original basetype could have been a typedef'd type.  */
9394           basetype = BINFO_TYPE (base_binfo);
9395
9396           /* Inherit flags from the base.  */
9397           TYPE_HAS_NEW_OPERATOR (ref)
9398             |= TYPE_HAS_NEW_OPERATOR (basetype);
9399           TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9400             |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9401           TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9402           TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
9403           CLASSTYPE_DIAMOND_SHAPED_P (ref)
9404             |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
9405           CLASSTYPE_REPEATED_BASE_P (ref)
9406             |= CLASSTYPE_REPEATED_BASE_P (basetype);
9407         }
9408
9409       /* We must do this test after we've seen through a typedef
9410          type.  */
9411       if (TYPE_MARKED_P (basetype))
9412         {
9413           if (basetype == ref)
9414             error ("recursive type %qT undefined", basetype);
9415           else
9416             error ("duplicate base type %qT invalid", basetype);
9417           continue;
9418         }
9419       TYPE_MARKED_P (basetype) = 1;
9420
9421       base_binfo = copy_binfo (base_binfo, basetype, ref,
9422                                &igo_prev, via_virtual);
9423       if (!BINFO_INHERITANCE_CHAIN (base_binfo))
9424         BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
9425
9426       BINFO_BASE_APPEND (binfo, base_binfo);
9427       BINFO_BASE_ACCESS_APPEND (binfo, access);
9428     }
9429
9430   if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
9431     /* If we have space in the vbase vector, we must have shared at
9432        least one of them, and are therefore diamond shaped.  */
9433     CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
9434
9435   /* Unmark all the types.  */
9436   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
9437     TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9438   TYPE_MARKED_P (ref) = 0;
9439
9440   /* Now see if we have a repeated base type.  */
9441   if (!CLASSTYPE_REPEATED_BASE_P (ref))
9442     {
9443       for (base_binfo = binfo; base_binfo;
9444            base_binfo = TREE_CHAIN (base_binfo))
9445         {
9446           if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9447             {
9448               CLASSTYPE_REPEATED_BASE_P (ref) = 1;
9449               break;
9450             }
9451           TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
9452         }
9453       for (base_binfo = binfo; base_binfo;
9454            base_binfo = TREE_CHAIN (base_binfo))
9455         if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9456           TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9457         else
9458           break;
9459     }
9460 }
9461
9462 \f
9463 /* Begin compiling the definition of an enumeration type.
9464    NAME is its name.
9465    Returns the type object, as yet incomplete.
9466    Also records info about it so that build_enumerator
9467    may be used to declare the individual values as they are read.  */
9468
9469 tree
9470 start_enum (tree name)
9471 {
9472   tree enumtype;
9473
9474   gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9475
9476   /* If this is the real definition for a previous forward reference,
9477      fill in the contents in the same object that used to be the
9478      forward reference.  */
9479
9480   enumtype = lookup_and_check_tag (enum_type, name,
9481                                    /*tag_scope=*/ts_current,
9482                                    /*template_header_p=*/false);
9483
9484   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9485     {
9486       error ("multiple definition of %q#T", enumtype);
9487       error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9488       /* Clear out TYPE_VALUES, and start again.  */
9489       TYPE_VALUES (enumtype) = NULL_TREE;
9490     }
9491   else
9492     {
9493       /* In case of error, make a dummy enum to allow parsing to
9494          continue.  */
9495       if (enumtype == error_mark_node)
9496         name = make_anon_name ();
9497
9498       enumtype = make_node (ENUMERAL_TYPE);
9499       enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
9500     }
9501
9502   return enumtype;
9503 }
9504
9505 /* After processing and defining all the values of an enumeration type,
9506    install their decls in the enumeration type and finish it off.
9507    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
9508
9509 void
9510 finish_enum (tree enumtype)
9511 {
9512   tree values;
9513   tree decl;
9514   tree value;
9515   tree minnode;
9516   tree maxnode;
9517   tree t;
9518   bool unsignedp;
9519   bool use_short_enum;
9520   int lowprec;
9521   int highprec;
9522   int precision;
9523   integer_type_kind itk;
9524   tree underlying_type = NULL_TREE;
9525
9526   /* We built up the VALUES in reverse order.  */
9527   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9528
9529   /* For an enum defined in a template, just set the type of the values;
9530      all further processing is postponed until the template is
9531      instantiated.  We need to set the type so that tsubst of a CONST_DECL
9532      works.  */
9533   if (processing_template_decl)
9534     {
9535       for (values = TYPE_VALUES (enumtype);
9536            values;
9537            values = TREE_CHAIN (values))
9538         TREE_TYPE (TREE_VALUE (values)) = enumtype;
9539       if (at_function_scope_p ())
9540         add_stmt (build_min (TAG_DEFN, enumtype));
9541       return;
9542     }
9543
9544   /* Determine the minimum and maximum values of the enumerators.  */
9545   if (TYPE_VALUES (enumtype))
9546     {
9547       minnode = maxnode = NULL_TREE;
9548
9549       for (values = TYPE_VALUES (enumtype);
9550            values;
9551            values = TREE_CHAIN (values))
9552         {
9553           decl = TREE_VALUE (values);
9554
9555           /* [dcl.enum]: Following the closing brace of an enum-specifier,
9556              each enumerator has the type of its enumeration.  Prior to the
9557              closing brace, the type of each enumerator is the type of its
9558              initializing value.  */
9559           TREE_TYPE (decl) = enumtype;
9560
9561           /* Update the minimum and maximum values, if appropriate.  */
9562           value = DECL_INITIAL (decl);
9563           /* Figure out what the minimum and maximum values of the
9564              enumerators are.  */
9565           if (!minnode)
9566             minnode = maxnode = value;
9567           else if (tree_int_cst_lt (maxnode, value))
9568             maxnode = value;
9569           else if (tree_int_cst_lt (value, minnode))
9570             minnode = value;
9571         }
9572     }
9573   else
9574     /* [dcl.enum]
9575
9576        If the enumerator-list is empty, the underlying type is as if
9577        the enumeration had a single enumerator with value 0.  */
9578     minnode = maxnode = integer_zero_node;
9579
9580   /* Compute the number of bits require to represent all values of the
9581      enumeration.  We must do this before the type of MINNODE and
9582      MAXNODE are transformed, since min_precision relies on the
9583      TREE_TYPE of the value it is passed.  */
9584   unsignedp = tree_int_cst_sgn (minnode) >= 0;
9585   lowprec = min_precision (minnode, unsignedp);
9586   highprec = min_precision (maxnode, unsignedp);
9587   precision = MAX (lowprec, highprec);
9588
9589   /* Determine the underlying type of the enumeration.
9590
9591        [dcl.enum]
9592
9593        The underlying type of an enumeration is an integral type that
9594        can represent all the enumerator values defined in the
9595        enumeration.  It is implementation-defined which integral type is
9596        used as the underlying type for an enumeration except that the
9597        underlying type shall not be larger than int unless the value of
9598        an enumerator cannot fit in an int or unsigned int.
9599
9600      We use "int" or an "unsigned int" as the underlying type, even if
9601      a smaller integral type would work, unless the user has
9602      explicitly requested that we use the smallest possible type.  The
9603      user can request that for all enumerations with a command line
9604      flag, or for just one enumeration with an attribute.  */
9605
9606   use_short_enum = flag_short_enums
9607     || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
9608
9609   for (itk = (use_short_enum ? itk_char : itk_int);
9610        itk != itk_none;
9611        itk++)
9612     {
9613       underlying_type = integer_types[itk];
9614       if (TYPE_PRECISION (underlying_type) >= precision
9615           && TYPE_UNSIGNED (underlying_type) == unsignedp)
9616         break;
9617     }
9618   if (itk == itk_none)
9619     {
9620       /* DR 377
9621
9622          IF no integral type can represent all the enumerator values, the
9623          enumeration is ill-formed.  */
9624       error ("no integral type can represent all of the enumerator values "
9625              "for %qT", enumtype);
9626       precision = TYPE_PRECISION (long_long_integer_type_node);
9627       underlying_type = integer_types[itk_unsigned_long_long];
9628     }
9629
9630   /* Compute the minium and maximum values for the type.
9631
9632      [dcl.enum]
9633
9634      For an enumeration where emin is the smallest enumerator and emax
9635      is the largest, the values of the enumeration are the values of the
9636      underlying type in the range bmin to bmax, where bmin and bmax are,
9637      respectively, the smallest and largest values of the smallest bit-
9638      field that can store emin and emax.  */
9639
9640   /* The middle-end currently assumes that types with TYPE_PRECISION
9641      narrower than their underlying type are suitably zero or sign
9642      extended to fill their mode.  g++ doesn't make these guarantees.
9643      Until the middle-end can represent such paradoxical types, we
9644      set the TYPE_PRECISION to the width of the underlying type.  */
9645   TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
9646
9647   set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
9648
9649   /* [dcl.enum]
9650
9651      The value of sizeof() applied to an enumeration type, an object
9652      of an enumeration type, or an enumerator, is the value of sizeof()
9653      applied to the underlying type.  */
9654   TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
9655   TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
9656   TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
9657   TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
9658   TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
9659   TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
9660
9661   /* Convert each of the enumerators to the type of the underlying
9662      type of the enumeration.  */
9663   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
9664     {
9665       decl = TREE_VALUE (values);
9666       value = perform_implicit_conversion (underlying_type,
9667                                            DECL_INITIAL (decl));
9668
9669       /* Do not clobber shared ints.  */
9670       value = copy_node (value);
9671
9672       TREE_TYPE (value) = enumtype;
9673       DECL_INITIAL (decl) = value;
9674       TREE_VALUE (values) = value;
9675     }
9676
9677   /* Fix up all variant types of this enum type.  */
9678   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
9679     {
9680       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
9681       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
9682       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
9683       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
9684       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
9685       TYPE_MODE (t) = TYPE_MODE (enumtype);
9686       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
9687       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
9688       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
9689       TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
9690     }
9691
9692   /* Finish debugging output for this type.  */
9693   rest_of_type_compilation (enumtype, namespace_bindings_p ());
9694 }
9695
9696 /* Build and install a CONST_DECL for an enumeration constant of the
9697    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9698    Assignment of sequential values by default is handled here.  */
9699
9700 void
9701 build_enumerator (tree name, tree value, tree enumtype)
9702 {
9703   tree decl;
9704   tree context;
9705   tree type;
9706
9707   /* If the VALUE was erroneous, pretend it wasn't there; that will
9708      result in the enum being assigned the next value in sequence.  */
9709   if (value == error_mark_node)
9710     value = NULL_TREE;
9711
9712   /* Remove no-op casts from the value.  */
9713   if (value)
9714     STRIP_TYPE_NOPS (value);
9715
9716   if (! processing_template_decl)
9717     {
9718       /* Validate and default VALUE.  */
9719       if (value != NULL_TREE)
9720         {
9721           value = integral_constant_value (value);
9722
9723           if (TREE_CODE (value) == INTEGER_CST)
9724             {
9725               value = perform_integral_promotions (value);
9726               constant_expression_warning (value);
9727             }
9728           else
9729             {
9730               error ("enumerator value for %qD not integer constant", name);
9731               value = NULL_TREE;
9732             }
9733         }
9734
9735       /* Default based on previous value.  */
9736       if (value == NULL_TREE)
9737         {
9738           if (TYPE_VALUES (enumtype))
9739             {
9740               HOST_WIDE_INT hi;
9741               unsigned HOST_WIDE_INT lo;
9742               tree prev_value;
9743               bool overflowed;
9744
9745               /* The next value is the previous value plus one.  We can
9746                  safely assume that the previous value is an INTEGER_CST.
9747                  add_double doesn't know the type of the target expression,
9748                  so we must check with int_fits_type_p as well.  */
9749               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
9750               overflowed = add_double (TREE_INT_CST_LOW (prev_value),
9751                                        TREE_INT_CST_HIGH (prev_value),
9752                                        1, 0, &lo, &hi);
9753               value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
9754               overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
9755
9756               if (overflowed)
9757                 error ("overflow in enumeration values at %qD", name);
9758             }
9759           else
9760             value = integer_zero_node;
9761         }
9762
9763       /* Remove no-op casts from the value.  */
9764       STRIP_TYPE_NOPS (value);
9765     }
9766
9767   /* C++ associates enums with global, function, or class declarations.  */
9768   context = current_scope ();
9769
9770   /* Build the actual enumeration constant.  Note that the enumeration
9771     constants have the type of their initializers until the
9772     enumeration is complete:
9773
9774       [ dcl.enum ]
9775
9776       Following the closing brace of an enum-specifier, each enumer-
9777       ator has the type of its enumeration.  Prior to the closing
9778       brace, the type of each enumerator is the type of its
9779       initializing value.
9780
9781     In finish_enum we will reset the type.  Of course, if we're
9782     processing a template, there may be no value.  */
9783   type = value ? TREE_TYPE (value) : NULL_TREE;
9784
9785   if (context && context == current_class_type)
9786     /* This enum declaration is local to the class.  We need the full
9787        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
9788     decl = build_lang_decl (CONST_DECL, name, type);
9789   else
9790     /* It's a global enum, or it's local to a function.  (Note local to
9791       a function could mean local to a class method.  */
9792     decl = build_decl (CONST_DECL, name, type);
9793
9794   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
9795   TREE_CONSTANT (decl) = 1;
9796   TREE_INVARIANT (decl) = 1;
9797   TREE_READONLY (decl) = 1;
9798   DECL_INITIAL (decl) = value;
9799
9800   if (context && context == current_class_type)
9801     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
9802        on the TYPE_FIELDS list for `S'.  (That's so that you can say
9803        things like `S::i' later.)  */
9804     finish_member_declaration (decl);
9805   else
9806     pushdecl (decl);
9807
9808   /* Add this enumeration constant to the list for this type.  */
9809   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
9810 }
9811
9812 \f
9813 /* We're defining DECL.  Make sure that it's type is OK.  */
9814
9815 static void
9816 check_function_type (tree decl, tree current_function_parms)
9817 {
9818   tree fntype = TREE_TYPE (decl);
9819   tree return_type = complete_type (TREE_TYPE (fntype));
9820
9821   /* In a function definition, arg types must be complete.  */
9822   require_complete_types_for_parms (current_function_parms);
9823
9824   if (dependent_type_p (return_type))
9825     return;
9826   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
9827     {
9828       error ("return type %q#T is incomplete", TREE_TYPE (fntype));
9829
9830       /* Make it return void instead, but don't change the
9831          type of the DECL_RESULT, in case we have a named return value.  */
9832       if (TREE_CODE (fntype) == METHOD_TYPE)
9833         {
9834           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
9835           TREE_TYPE (decl)
9836             = build_method_type_directly (ctype,
9837                                           void_type_node,
9838                                           FUNCTION_ARG_CHAIN (decl));
9839         }
9840       else
9841         TREE_TYPE (decl)
9842           = build_function_type (void_type_node,
9843                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
9844       TREE_TYPE (decl)
9845         = build_exception_variant (fntype,
9846                                    TYPE_RAISES_EXCEPTIONS (fntype));
9847     }
9848   else
9849     abstract_virtuals_error (decl, TREE_TYPE (fntype));
9850 }
9851
9852 /* Create the FUNCTION_DECL for a function definition.
9853    DECLSPECS and DECLARATOR are the parts of the declaration;
9854    they describe the function's name and the type it returns,
9855    but twisted together in a fashion that parallels the syntax of C.
9856
9857    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
9858    DECLARATOR is really the DECL for the function we are about to
9859    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
9860    indicating that the function is an inline defined in-class.
9861
9862    This function creates a binding context for the function body
9863    as well as setting up the FUNCTION_DECL in current_function_decl.
9864
9865    For C++, we must first check whether that datum makes any sense.
9866    For example, "class A local_a(1,2);" means that variable local_a
9867    is an aggregate of type A, which should have a constructor
9868    applied to it with the argument list [1, 2].  */
9869
9870 void
9871 start_preparsed_function (tree decl1, tree attrs, int flags)
9872 {
9873   tree ctype = NULL_TREE;
9874   tree fntype;
9875   tree restype;
9876   int doing_friend = 0;
9877   struct cp_binding_level *bl;
9878   tree current_function_parms;
9879   struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename));
9880
9881   /* Sanity check.  */
9882   gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
9883   gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
9884
9885   fntype = TREE_TYPE (decl1);
9886   if (TREE_CODE (fntype) == METHOD_TYPE)
9887     ctype = TYPE_METHOD_BASETYPE (fntype);
9888
9889   /* ISO C++ 11.4/5.  A friend function defined in a class is in
9890      the (lexical) scope of the class in which it is defined.  */
9891   if (!ctype && DECL_FRIEND_P (decl1))
9892     {
9893       ctype = DECL_FRIEND_CONTEXT (decl1);
9894
9895       /* CTYPE could be null here if we're dealing with a template;
9896          for example, `inline friend float foo()' inside a template
9897          will have no CTYPE set.  */
9898       if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
9899         ctype = NULL_TREE;
9900       else
9901         doing_friend = 1;
9902     }
9903
9904   if (DECL_DECLARED_INLINE_P (decl1)
9905       && lookup_attribute ("noinline", attrs))
9906     warning ("%Jinline function %qD given attribute noinline", decl1, decl1);
9907
9908   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
9909     /* This is a constructor, we must ensure that any default args
9910        introduced by this definition are propagated to the clones
9911        now. The clones are used directly in overload resolution.  */
9912     adjust_clone_args (decl1);
9913
9914   /* Sometimes we don't notice that a function is a static member, and
9915      build a METHOD_TYPE for it.  Fix that up now.  */
9916   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
9917       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
9918     {
9919       revert_static_member_fn (decl1);
9920       ctype = NULL_TREE;
9921     }
9922
9923   /* Set up current_class_type, and enter the scope of the class, if
9924      appropriate.  */
9925   if (ctype)
9926     push_nested_class (ctype);
9927   else if (DECL_STATIC_FUNCTION_P (decl1))
9928     push_nested_class (DECL_CONTEXT (decl1));
9929
9930   /* Now that we have entered the scope of the class, we must restore
9931      the bindings for any template parameters surrounding DECL1, if it
9932      is an inline member template.  (Order is important; consider the
9933      case where a template parameter has the same name as a field of
9934      the class.)  It is not until after this point that
9935      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
9936   if (flags & SF_INCLASS_INLINE)
9937     maybe_begin_member_template_processing (decl1);
9938
9939   /* Effective C++ rule 15.  */
9940   if (warn_ecpp
9941       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
9942       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
9943     warning ("%<operator=%> should return a reference to %<*this%>");
9944
9945   /* Make the init_value nonzero so pushdecl knows this is not tentative.
9946      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
9947   if (!DECL_INITIAL (decl1))
9948     DECL_INITIAL (decl1) = error_mark_node;
9949
9950   /* This function exists in static storage.
9951      (This does not mean `static' in the C sense!)  */
9952   TREE_STATIC (decl1) = 1;
9953
9954   /* We must call push_template_decl after current_class_type is set
9955      up.  (If we are processing inline definitions after exiting a
9956      class scope, current_class_type will be NULL_TREE until set above
9957      by push_nested_class.)  */
9958   if (processing_template_decl)
9959     {
9960       /* FIXME: Handle error_mark_node more gracefully.  */
9961       tree newdecl1 = push_template_decl (decl1);
9962       if (newdecl1 != error_mark_node)
9963         decl1 = newdecl1;
9964     }
9965
9966   /* We are now in the scope of the function being defined.  */
9967   current_function_decl = decl1;
9968
9969   /* Save the parm names or decls from this function's declarator
9970      where store_parm_decls will find them.  */
9971   current_function_parms = DECL_ARGUMENTS (decl1);
9972
9973   /* Make sure the parameter and return types are reasonable.  When
9974      you declare a function, these types can be incomplete, but they
9975      must be complete when you define the function.  */
9976   check_function_type (decl1, current_function_parms);
9977
9978   /* Build the return declaration for the function.  */
9979   restype = TREE_TYPE (fntype);
9980   /* Promote the value to int before returning it.  */
9981   if (c_promoting_integer_type_p (restype))
9982     restype = type_promotes_to (restype);
9983   if (DECL_RESULT (decl1) == NULL_TREE)
9984     {
9985       tree resdecl;
9986
9987       resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
9988       DECL_ARTIFICIAL (resdecl) = 1;
9989       DECL_IGNORED_P (resdecl) = 1;
9990       DECL_RESULT (decl1) = resdecl;
9991
9992       cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
9993     }
9994
9995   /* Initialize RTL machinery.  We cannot do this until
9996      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
9997      even when processing a template; this is how we get
9998      CFUN set up, and our per-function variables initialized.
9999      FIXME factor out the non-RTL stuff.  */
10000   bl = current_binding_level;
10001   allocate_struct_function (decl1);
10002   current_binding_level = bl;
10003
10004   /* Even though we're inside a function body, we still don't want to
10005      call expand_expr to calculate the size of a variable-sized array.
10006      We haven't necessarily assigned RTL to all variables yet, so it's
10007      not safe to try to expand expressions involving them.  */
10008   cfun->x_dont_save_pending_sizes_p = 1;
10009
10010   /* Start the statement-tree, start the tree now.  */
10011   DECL_SAVED_TREE (decl1) = push_stmt_list ();
10012
10013   /* Let the user know we're compiling this function.  */
10014   announce_function (decl1);
10015
10016   /* Record the decl so that the function name is defined.
10017      If we already have a decl for this name, and it is a FUNCTION_DECL,
10018      use the old decl.  */
10019   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
10020     {
10021       /* A specialization is not used to guide overload resolution.  */
10022       if (!DECL_FUNCTION_MEMBER_P (decl1)
10023           && !(DECL_USE_TEMPLATE (decl1) &&
10024                PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
10025         {
10026           tree olddecl = pushdecl (decl1);
10027
10028           if (olddecl == error_mark_node)
10029             /* If something went wrong when registering the declaration,
10030                use DECL1; we have to have a FUNCTION_DECL to use when
10031                parsing the body of the function.  */
10032             ;
10033           else
10034             /* Otherwise, OLDDECL is either a previous declaration of
10035                the same function or DECL1 itself.  */
10036             decl1 = olddecl;
10037         }
10038       else
10039         {
10040           /* We need to set the DECL_CONTEXT.  */
10041           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
10042             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
10043           /* And make sure we have enough default args.  */
10044           check_default_args (decl1);
10045         }
10046       fntype = TREE_TYPE (decl1);
10047     }
10048
10049   /* Determine the ELF visibility attribute for the function.  We must
10050      not do this before calling "pushdecl", as we must allow
10051      "duplicate_decls" to merge any attributes appropriately.  */
10052   if (!DECL_CLONED_FUNCTION_P (decl1))
10053     determine_visibility (decl1);
10054
10055   /* Reset these in case the call to pushdecl changed them.  */
10056   current_function_decl = decl1;
10057   cfun->decl = decl1;
10058
10059   /* If we are (erroneously) defining a function that we have already
10060      defined before, wipe out what we knew before.  */
10061   if (!DECL_PENDING_INLINE_P (decl1))
10062     DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
10063
10064   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
10065     {
10066       /* We know that this was set up by `grokclassfn'.  We do not
10067          wait until `store_parm_decls', since evil parse errors may
10068          never get us to that point.  Here we keep the consistency
10069          between `current_class_type' and `current_class_ptr'.  */
10070       tree t = DECL_ARGUMENTS (decl1);
10071
10072       gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
10073       gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
10074
10075       cp_function_chain->x_current_class_ref
10076         = build_indirect_ref (t, NULL);
10077       cp_function_chain->x_current_class_ptr = t;
10078
10079       /* Constructors and destructors need to know whether they're "in
10080          charge" of initializing virtual base classes.  */
10081       t = TREE_CHAIN (t);
10082       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
10083         {
10084           current_in_charge_parm = t;
10085           t = TREE_CHAIN (t);
10086         }
10087       if (DECL_HAS_VTT_PARM_P (decl1))
10088         {
10089           gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
10090           current_vtt_parm = t;
10091         }
10092     }
10093
10094   if (DECL_INTERFACE_KNOWN (decl1))
10095     {
10096       tree ctx = decl_function_context (decl1);
10097
10098       if (DECL_NOT_REALLY_EXTERN (decl1))
10099         DECL_EXTERNAL (decl1) = 0;
10100
10101       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
10102           && TREE_PUBLIC (ctx))
10103         /* This is a function in a local class in an extern inline
10104            function.  */
10105         comdat_linkage (decl1);
10106     }
10107   /* If this function belongs to an interface, it is public.
10108      If it belongs to someone else's interface, it is also external.
10109      This only affects inlines and template instantiations.  */
10110   else if (finfo->interface_unknown == 0
10111            && ! DECL_TEMPLATE_INSTANTIATION (decl1))
10112     {
10113       if (DECL_DECLARED_INLINE_P (decl1)
10114           || DECL_TEMPLATE_INSTANTIATION (decl1)
10115           || processing_template_decl)
10116         {
10117           DECL_EXTERNAL (decl1)
10118             = (finfo->interface_only
10119                || (DECL_DECLARED_INLINE_P (decl1)
10120                    && ! flag_implement_inlines
10121                    && !DECL_VINDEX (decl1)));
10122
10123           /* For WIN32 we also want to put these in linkonce sections.  */
10124           maybe_make_one_only (decl1);
10125         }
10126       else
10127         DECL_EXTERNAL (decl1) = 0;
10128       DECL_NOT_REALLY_EXTERN (decl1) = 0;
10129       DECL_INTERFACE_KNOWN (decl1) = 1;
10130       /* If this function is in an interface implemented in this file,
10131          make sure that the backend knows to emit this function
10132          here.  */
10133       if (!DECL_EXTERNAL (decl1))
10134         mark_needed (decl1);
10135     }
10136   else if (finfo->interface_unknown && finfo->interface_only
10137            && ! DECL_TEMPLATE_INSTANTIATION (decl1))
10138     {
10139       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
10140          interface, we will have both finfo->interface_unknown and
10141          finfo->interface_only set.  In that case, we don't want to
10142          use the normal heuristics because someone will supply a
10143          #pragma implementation elsewhere, and deducing it here would
10144          produce a conflict.  */
10145       comdat_linkage (decl1);
10146       DECL_EXTERNAL (decl1) = 0;
10147       DECL_INTERFACE_KNOWN (decl1) = 1;
10148       DECL_DEFER_OUTPUT (decl1) = 1;
10149     }
10150   else
10151     {
10152       /* This is a definition, not a reference.
10153          So clear DECL_EXTERNAL.  */
10154       DECL_EXTERNAL (decl1) = 0;
10155
10156       if ((DECL_DECLARED_INLINE_P (decl1)
10157            || DECL_TEMPLATE_INSTANTIATION (decl1))
10158           && ! DECL_INTERFACE_KNOWN (decl1)
10159           /* Don't try to defer nested functions for now.  */
10160           && ! decl_function_context (decl1))
10161         DECL_DEFER_OUTPUT (decl1) = 1;
10162       else
10163         DECL_INTERFACE_KNOWN (decl1) = 1;
10164     }
10165
10166   begin_scope (sk_function_parms, decl1);
10167
10168   ++function_depth;
10169
10170   if (DECL_DESTRUCTOR_P (decl1)
10171       || (DECL_CONSTRUCTOR_P (decl1)
10172           && targetm.cxx.cdtor_returns_this ()))
10173     {
10174       cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10175       DECL_CONTEXT (cdtor_label) = current_function_decl;
10176     }
10177
10178   start_fname_decls ();
10179
10180   store_parm_decls (current_function_parms);
10181 }
10182
10183
10184 /* Like start_preparsed_function, except that instead of a
10185    FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
10186
10187    Returns 1 on success.  If the DECLARATOR is not suitable for a function
10188    (it defines a datum instead), we return 0, which tells
10189    yyparse to report a parse error.  */
10190
10191 int
10192 start_function (cp_decl_specifier_seq *declspecs,
10193                 const cp_declarator *declarator,
10194                 tree attrs)
10195 {
10196   tree decl1;
10197
10198   if (have_extern_spec)
10199     {
10200       declspecs->storage_class = sc_extern;
10201       /* This should only be done once on the outermost decl.  */
10202       have_extern_spec = false;
10203     }
10204
10205   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
10206   /* If the declarator is not suitable for a function definition,
10207      cause a syntax error.  */
10208   if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
10209     return 0;
10210
10211   /* If #pragma weak was used, mark the decl weak now.  */
10212   if (global_scope_p (current_binding_level))
10213     maybe_apply_pragma_weak (decl1);
10214
10215   if (DECL_MAIN_P (decl1))
10216     /* main must return int.  grokfndecl should have corrected it
10217        (and issued a diagnostic) if the user got it wrong.  */
10218     gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
10219                              integer_type_node));
10220
10221   start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
10222
10223   return 1;
10224 }
10225 \f
10226 /* Store the parameter declarations into the current function declaration.
10227    This is called after parsing the parameter declarations, before
10228    digesting the body of the function.
10229
10230    Also install to binding contour return value identifier, if any.  */
10231
10232 static void
10233 store_parm_decls (tree current_function_parms)
10234 {
10235   tree fndecl = current_function_decl;
10236   tree parm;
10237
10238   /* This is a chain of any other decls that came in among the parm
10239      declarations.  If a parm is declared with  enum {foo, bar} x;
10240      then CONST_DECLs for foo and bar are put here.  */
10241   tree nonparms = NULL_TREE;
10242
10243   if (current_function_parms)
10244     {
10245       /* This case is when the function was defined with an ANSI prototype.
10246          The parms already have decls, so we need not do anything here
10247          except record them as in effect
10248          and complain if any redundant old-style parm decls were written.  */
10249
10250       tree specparms = current_function_parms;
10251       tree next;
10252
10253       /* Must clear this because it might contain TYPE_DECLs declared
10254              at class level.  */
10255       current_binding_level->names = NULL;
10256
10257       /* If we're doing semantic analysis, then we'll call pushdecl
10258              for each of these.  We must do them in reverse order so that
10259              they end in the correct forward order.  */
10260       specparms = nreverse (specparms);
10261
10262       for (parm = specparms; parm; parm = next)
10263         {
10264           next = TREE_CHAIN (parm);
10265           if (TREE_CODE (parm) == PARM_DECL)
10266             {
10267               if (DECL_NAME (parm) == NULL_TREE
10268                   || TREE_CODE (parm) != VOID_TYPE)
10269                 pushdecl (parm);
10270               else
10271                 error ("parameter %qD declared void", parm);
10272             }
10273           else
10274             {
10275               /* If we find an enum constant or a type tag,
10276                  put it aside for the moment.  */
10277               TREE_CHAIN (parm) = NULL_TREE;
10278               nonparms = chainon (nonparms, parm);
10279             }
10280         }
10281
10282       /* Get the decls in their original chain order and record in the
10283          function.  This is all and only the PARM_DECLs that were
10284          pushed into scope by the loop above.  */
10285       DECL_ARGUMENTS (fndecl) = getdecls ();
10286     }
10287   else
10288     DECL_ARGUMENTS (fndecl) = NULL_TREE;
10289
10290   /* Now store the final chain of decls for the arguments
10291      as the decl-chain of the current lexical scope.
10292      Put the enumerators in as well, at the front so that
10293      DECL_ARGUMENTS is not modified.  */
10294   current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
10295
10296   /* For a cloned function, we've already got all the code we need;
10297      there's no need to add any extra bits.  */
10298   if (!DECL_CLONED_FUNCTION_P (fndecl))
10299     {
10300       /* Do the starting of the exception specifications, if we have any.  */
10301       if (flag_exceptions && !processing_template_decl
10302           && flag_enforce_eh_specs
10303           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10304         current_eh_spec_block = begin_eh_spec_block ();
10305     }
10306 }
10307
10308 \f
10309 /* We have finished doing semantic analysis on DECL, but have not yet
10310    generated RTL for its body.  Save away our current state, so that
10311    when we want to generate RTL later we know what to do.  */
10312
10313 static void
10314 save_function_data (tree decl)
10315 {
10316   struct language_function *f;
10317
10318   /* Save the language-specific per-function data so that we can
10319      get it back when we really expand this function.  */
10320   gcc_assert (!DECL_PENDING_INLINE_P (decl));
10321
10322   /* Make a copy.  */
10323   f = GGC_NEW (struct language_function);
10324   memcpy (f, cp_function_chain, sizeof (struct language_function));
10325   DECL_SAVED_FUNCTION_DATA (decl) = f;
10326
10327   /* Clear out the bits we don't need.  */
10328   f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10329   f->x_named_label_uses = NULL;
10330   f->bindings = NULL;
10331   f->x_local_names = NULL;
10332 }
10333
10334
10335 /* Set the return value of the constructor (if present).  */
10336
10337 static void
10338 finish_constructor_body (void)
10339 {
10340   tree val;
10341   tree exprstmt;
10342
10343   if (targetm.cxx.cdtor_returns_this ())
10344     {
10345       /* Any return from a constructor will end up here.  */
10346       add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10347
10348       val = DECL_ARGUMENTS (current_function_decl);
10349       val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10350                     DECL_RESULT (current_function_decl), val);
10351       /* Return the address of the object.  */
10352       exprstmt = build_stmt (RETURN_EXPR, val);
10353       add_stmt (exprstmt);
10354     }
10355 }
10356
10357 /* Do all the processing for the beginning of a destructor; set up the
10358    vtable pointers and cleanups for bases and members.  */
10359
10360 static void
10361 begin_destructor_body (void)
10362 {
10363   tree if_stmt;
10364   tree compound_stmt;
10365
10366   /* If the dtor is empty, and we know there is not any possible
10367      way we could use any vtable entries, before they are possibly
10368      set by a base class dtor, we don't have to setup the vtables,
10369      as we know that any base class dtor will set up any vtables
10370      it needs.  We avoid MI, because one base class dtor can do a
10371      virtual dispatch to an overridden function that would need to
10372      have a non-related vtable set up, we cannot avoid setting up
10373      vtables in that case.  We could change this to see if there
10374      is just one vtable.
10375
10376      ??? In the destructor for a class, the vtables are set
10377      appropriately for that class.  There will be no non-related
10378      vtables.  jason 2001-12-11.  */
10379   if_stmt = begin_if_stmt ();
10380
10381   /* If it is not safe to avoid setting up the vtables, then
10382      someone will change the condition to be boolean_true_node.
10383      (Actually, for now, we do not have code to set the condition
10384      appropriately, so we just assume that we always need to
10385      initialize the vtables.)  */
10386   finish_if_stmt_cond (boolean_true_node, if_stmt);
10387
10388   compound_stmt = begin_compound_stmt (0);
10389
10390   /* Make all virtual function table pointers in non-virtual base
10391      classes point to CURRENT_CLASS_TYPE's virtual function
10392      tables.  */
10393   initialize_vtbl_ptrs (current_class_ptr);
10394
10395   finish_compound_stmt (compound_stmt);
10396   finish_then_clause (if_stmt);
10397   finish_if_stmt (if_stmt);
10398
10399   /* And insert cleanups for our bases and members so that they
10400      will be properly destroyed if we throw.  */
10401   push_base_cleanups ();
10402 }
10403
10404 /* At the end of every destructor we generate code to delete the object if
10405    necessary.  Do that now.  */
10406
10407 static void
10408 finish_destructor_body (void)
10409 {
10410   tree exprstmt;
10411
10412   /* Any return from a destructor will end up here; that way all base
10413      and member cleanups will be run when the function returns.  */
10414   add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10415
10416   /* In a virtual destructor, we must call delete.  */
10417   if (DECL_VIRTUAL_P (current_function_decl))
10418     {
10419       tree if_stmt;
10420       tree virtual_size = cxx_sizeof (current_class_type);
10421
10422       /* [class.dtor]
10423
10424       At the point of definition of a virtual destructor (including
10425       an implicit definition), non-placement operator delete shall
10426       be looked up in the scope of the destructor's class and if
10427       found shall be accessible and unambiguous.  */
10428       exprstmt = build_op_delete_call
10429         (DELETE_EXPR, current_class_ptr, virtual_size,
10430          /*global_p=*/false, NULL_TREE);
10431
10432       if_stmt = begin_if_stmt ();
10433       finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
10434                                    current_in_charge_parm,
10435                                    integer_one_node),
10436                            if_stmt);
10437       finish_expr_stmt (exprstmt);
10438       finish_then_clause (if_stmt);
10439       finish_if_stmt (if_stmt);
10440     }
10441
10442   if (targetm.cxx.cdtor_returns_this ())
10443     {
10444       tree val;
10445
10446       val = DECL_ARGUMENTS (current_function_decl);
10447       val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10448                     DECL_RESULT (current_function_decl), val);
10449       /* Return the address of the object.  */
10450       exprstmt = build_stmt (RETURN_EXPR, val);
10451       add_stmt (exprstmt);
10452     }
10453 }
10454
10455 /* Do the necessary processing for the beginning of a function body, which
10456    in this case includes member-initializers, but not the catch clauses of
10457    a function-try-block.  Currently, this means opening a binding level
10458    for the member-initializers (in a ctor) and member cleanups (in a dtor).
10459    In other functions, this isn't necessary, but it doesn't hurt.  */
10460
10461 tree
10462 begin_function_body (void)
10463 {
10464   tree stmt;
10465
10466   if (processing_template_decl)
10467     /* Do nothing now.  */;
10468   else
10469     /* Always keep the BLOCK node associated with the outermost pair of
10470        curly braces of a function.  These are needed for correct
10471        operation of dwarfout.c.  */
10472     keep_next_level (true);
10473
10474   stmt = begin_compound_stmt (BCS_FN_BODY);
10475
10476   if (processing_template_decl)
10477     /* Do nothing now.  */;
10478   else if (DECL_DESTRUCTOR_P (current_function_decl))
10479     begin_destructor_body ();
10480
10481   return stmt;
10482 }
10483
10484 /* Do the processing for the end of a function body.  Currently, this means
10485    closing out the cleanups for fully-constructed bases and members, and in
10486    the case of the destructor, deleting the object if desired.  Again, this
10487    is only meaningful for [cd]tors, since they are the only functions where
10488    there is a significant distinction between the main body and any
10489    function catch clauses.  Handling, say, main() return semantics here
10490    would be wrong, as flowing off the end of a function catch clause for
10491    main() would also need to return 0.  */
10492
10493 void
10494 finish_function_body (tree compstmt)
10495 {
10496   /* Close the block.  */
10497   finish_compound_stmt (compstmt);
10498
10499   if (processing_template_decl)
10500     /* Do nothing now.  */;
10501   else if (DECL_CONSTRUCTOR_P (current_function_decl))
10502     finish_constructor_body ();
10503   else if (DECL_DESTRUCTOR_P (current_function_decl))
10504     finish_destructor_body ();
10505 }
10506
10507 /* Finish up a function declaration and compile that function
10508    all the way to assembler language output.  The free the storage
10509    for the function definition.
10510
10511    FLAGS is a bitwise or of the following values:
10512      2 - INCLASS_INLINE
10513        We just finished processing the body of an in-class inline
10514        function definition.  (This processing will have taken place
10515        after the class definition is complete.)  */
10516
10517 tree
10518 finish_function (int flags)
10519 {
10520   tree fndecl = current_function_decl;
10521   tree fntype, ctype = NULL_TREE;
10522   int inclass_inline = (flags & 2) != 0;
10523   int nested;
10524
10525   /* When we get some parse errors, we can end up without a
10526      current_function_decl, so cope.  */
10527   if (fndecl == NULL_TREE)
10528     return error_mark_node;
10529
10530   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10531       && DECL_VIRTUAL_P (fndecl)
10532       && !processing_template_decl)
10533     {
10534       tree fnclass = DECL_CONTEXT (fndecl);
10535       if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10536         keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10537     }
10538
10539   nested = function_depth > 1;
10540   fntype = TREE_TYPE (fndecl);
10541
10542   /*  TREE_READONLY (fndecl) = 1;
10543       This caused &foo to be of type ptr-to-const-function
10544       which then got a warning when stored in a ptr-to-function variable.  */
10545
10546   gcc_assert (building_stmt_tree ());
10547
10548   /* For a cloned function, we've already got all the code we need;
10549      there's no need to add any extra bits.  */
10550   if (!DECL_CLONED_FUNCTION_P (fndecl))
10551     {
10552       if (DECL_MAIN_P (current_function_decl))
10553         {
10554           tree stmt;
10555
10556           /* Make it so that `main' always returns 0 by default (or
10557              1 for VMS).  */
10558 #if VMS_TARGET
10559           stmt = finish_return_stmt (integer_one_node);
10560 #else
10561           stmt = finish_return_stmt (integer_zero_node);
10562 #endif
10563           /* Hack.  We don't want the middle-end to warn that this
10564              return is unreachable, so put the statement on the
10565              special line 0.  */
10566 #ifdef USE_MAPPED_LOCATION
10567           SET_EXPR_LOCATION (stmt, UNKNOWN_LOCATION);
10568 #else
10569           annotate_with_file_line (stmt, input_filename, 0);
10570 #endif
10571         }
10572
10573       /* Finish dealing with exception specifiers.  */
10574       if (flag_exceptions && !processing_template_decl
10575           && flag_enforce_eh_specs
10576           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10577         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10578                               (TREE_TYPE (current_function_decl)),
10579                               current_eh_spec_block);
10580     }
10581
10582   /* If we're saving up tree structure, tie off the function now.  */
10583   DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
10584
10585   finish_fname_decls ();
10586
10587   /* If this function can't throw any exceptions, remember that.  */
10588   if (!processing_template_decl
10589       && !cp_function_chain->can_throw
10590       && !flag_non_call_exceptions)
10591     TREE_NOTHROW (fndecl) = 1;
10592
10593   /* This must come after expand_function_end because cleanups might
10594      have declarations (from inline functions) that need to go into
10595      this function's blocks.  */
10596
10597   /* If the current binding level isn't the outermost binding level
10598      for this function, either there is a bug, or we have experienced
10599      syntax errors and the statement tree is malformed.  */
10600   if (current_binding_level->kind != sk_function_parms)
10601     {
10602       /* Make sure we have already experienced errors.  */
10603       gcc_assert (errorcount);
10604
10605       /* Throw away the broken statement tree and extra binding
10606          levels.  */
10607       DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
10608
10609       while (current_binding_level->kind != sk_function_parms)
10610         {
10611           if (current_binding_level->kind == sk_class)
10612             pop_nested_class ();
10613           else
10614             poplevel (0, 0, 0);
10615         }
10616     }
10617   poplevel (1, 0, 1);
10618
10619   /* Statements should always be full-expressions at the outermost set
10620      of curly braces for a function.  */
10621   gcc_assert (stmts_are_full_exprs_p ());
10622
10623   /* Set up the named return value optimization, if we can.  Candidate
10624      variables are selected in check_return_value.  */
10625   if (current_function_return_value)
10626     {
10627       tree r = current_function_return_value;
10628       tree outer;
10629
10630       if (r != error_mark_node
10631           /* This is only worth doing for fns that return in memory--and
10632              simpler, since we don't have to worry about promoted modes.  */
10633           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
10634           /* Only allow this for variables declared in the outer scope of
10635              the function so we know that their lifetime always ends with a
10636              return; see g++.dg/opt/nrv6.C.  We could be more flexible if
10637              we were to do this optimization in tree-ssa.  */
10638           && (outer = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl)))
10639           /* Skip the artificial function body block.  */
10640           && (outer = BLOCK_SUBBLOCKS (outer))
10641           && chain_member (r, BLOCK_VARS (outer)))
10642         finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
10643
10644       current_function_return_value = NULL_TREE;
10645     }
10646
10647   /* Remember that we were in class scope.  */
10648   if (current_class_name)
10649     ctype = current_class_type;
10650
10651   /* Must mark the RESULT_DECL as being in this function.  */
10652   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
10653
10654   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10655      to the FUNCTION_DECL node itself.  */
10656   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
10657
10658   /* Save away current state, if appropriate.  */
10659   if (!processing_template_decl)
10660     save_function_data (fndecl);
10661
10662   /* Complain if there's just no return statement.  */
10663   if (warn_return_type
10664       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
10665       && !dependent_type_p (TREE_TYPE (fntype))
10666       && !current_function_returns_value && !current_function_returns_null
10667       /* Don't complain if we abort or throw.  */
10668       && !current_function_returns_abnormally
10669       && !DECL_NAME (DECL_RESULT (fndecl))
10670       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
10671          inline function, as we might never be compiled separately.  */
10672       && (DECL_INLINE (fndecl) || processing_template_decl)
10673       /* Structor return values (if any) are set by the compiler.  */
10674       && !DECL_CONSTRUCTOR_P (fndecl)
10675       && !DECL_DESTRUCTOR_P (fndecl))
10676     warning ("no return statement in function returning non-void");
10677
10678   /* Store the end of the function, so that we get good line number
10679      info for the epilogue.  */
10680   cfun->function_end_locus = input_location;
10681
10682   /* Genericize before inlining.  */
10683   if (!processing_template_decl)
10684     {
10685       struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
10686       cp_genericize (fndecl);
10687       /* Clear out the bits we don't need.  */
10688       f->x_current_class_ptr = NULL;
10689       f->x_current_class_ref = NULL;
10690       f->x_eh_spec_block = NULL;
10691       f->x_in_charge_parm = NULL;
10692       f->x_vtt_parm = NULL;
10693       f->x_return_value = NULL;
10694       f->bindings = NULL;
10695
10696       /* Handle attribute((warn_unused_result)).  Relies on gimple input.  */
10697       c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
10698     }
10699   /* Clear out the bits we don't need.  */
10700   local_names = NULL;
10701   named_label_uses = NULL;
10702
10703   /* We're leaving the context of this function, so zap cfun.  It's still in
10704      DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation.  */
10705   cfun = NULL;
10706   current_function_decl = NULL;
10707
10708   /* If this is an in-class inline definition, we may have to pop the
10709      bindings for the template parameters that we added in
10710      maybe_begin_member_template_processing when start_function was
10711      called.  */
10712   if (inclass_inline)
10713     maybe_end_member_template_processing ();
10714
10715   /* Leave the scope of the class.  */
10716   if (ctype)
10717     pop_nested_class ();
10718
10719   --function_depth;
10720
10721   /* Clean up.  */
10722   if (! nested)
10723     /* Let the error reporting routines know that we're outside a
10724        function.  For a nested function, this value is used in
10725        cxx_pop_function_context and then reset via pop_function_context.  */
10726     current_function_decl = NULL_TREE;
10727
10728   return fndecl;
10729 }
10730 \f
10731 /* Create the FUNCTION_DECL for a function definition.
10732    DECLSPECS and DECLARATOR are the parts of the declaration;
10733    they describe the return type and the name of the function,
10734    but twisted together in a fashion that parallels the syntax of C.
10735
10736    This function creates a binding context for the function body
10737    as well as setting up the FUNCTION_DECL in current_function_decl.
10738
10739    Returns a FUNCTION_DECL on success.
10740
10741    If the DECLARATOR is not suitable for a function (it defines a datum
10742    instead), we return 0, which tells yyparse to report a parse error.
10743
10744    May return void_type_node indicating that this method is actually
10745    a friend.  See grokfield for more details.
10746
10747    Came here with a `.pushlevel' .
10748
10749    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
10750    CHANGES TO CODE IN `grokfield'.  */
10751
10752 tree
10753 start_method (cp_decl_specifier_seq *declspecs,
10754               const cp_declarator *declarator, tree attrlist)
10755 {
10756   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
10757                                 &attrlist);
10758
10759   if (fndecl == error_mark_node)
10760     return error_mark_node;
10761
10762   if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
10763     {
10764       error ("invalid member function declaration");
10765       return error_mark_node;
10766     }
10767
10768   if (attrlist)
10769     cplus_decl_attributes (&fndecl, attrlist, 0);
10770
10771   /* Pass friends other than inline friend functions back.  */
10772   if (fndecl == void_type_node)
10773     return fndecl;
10774
10775   if (DECL_IN_AGGR_P (fndecl))
10776     {
10777       if (DECL_CONTEXT (fndecl)
10778           && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
10779         error ("%qD is already defined in class %qT", fndecl,
10780                DECL_CONTEXT (fndecl));
10781       return void_type_node;
10782     }
10783
10784   check_template_shadow (fndecl);
10785
10786   DECL_DECLARED_INLINE_P (fndecl) = 1;
10787   if (flag_default_inline)
10788     DECL_INLINE (fndecl) = 1;
10789
10790   /* We process method specializations in finish_struct_1.  */
10791   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
10792     {
10793       fndecl = push_template_decl (fndecl);
10794       if (fndecl == error_mark_node)
10795         return fndecl;
10796     }
10797
10798   if (! DECL_FRIEND_P (fndecl))
10799     {
10800       if (TREE_CHAIN (fndecl))
10801         {
10802           fndecl = copy_node (fndecl);
10803           TREE_CHAIN (fndecl) = NULL_TREE;
10804         }
10805       grok_special_member_properties (fndecl);
10806     }
10807
10808   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
10809
10810   /* Make a place for the parms.  */
10811   begin_scope (sk_function_parms, fndecl);
10812
10813   DECL_IN_AGGR_P (fndecl) = 1;
10814   return fndecl;
10815 }
10816
10817 /* Go through the motions of finishing a function definition.
10818    We don't compile this method until after the whole class has
10819    been processed.
10820
10821    FINISH_METHOD must return something that looks as though it
10822    came from GROKFIELD (since we are defining a method, after all).
10823
10824    This is called after parsing the body of the function definition.
10825    STMTS is the chain of statements that makes up the function body.
10826
10827    DECL is the ..._DECL that `start_method' provided.  */
10828
10829 tree
10830 finish_method (tree decl)
10831 {
10832   tree fndecl = decl;
10833   tree old_initial;
10834
10835   tree link;
10836
10837   if (decl == void_type_node)
10838     return decl;
10839
10840   old_initial = DECL_INITIAL (fndecl);
10841
10842   /* Undo the level for the parms (from start_method).
10843      This is like poplevel, but it causes nothing to be
10844      saved.  Saving information here confuses symbol-table
10845      output routines.  Besides, this information will
10846      be correctly output when this method is actually
10847      compiled.  */
10848
10849   /* Clear out the meanings of the local variables of this level;
10850      also record in each decl which block it belongs to.  */
10851
10852   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
10853     {
10854       if (DECL_NAME (link) != NULL_TREE)
10855         pop_binding (DECL_NAME (link), link);
10856       gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
10857       DECL_CONTEXT (link) = NULL_TREE;
10858     }
10859
10860   poplevel (0, 0, 0);
10861
10862   DECL_INITIAL (fndecl) = old_initial;
10863
10864   /* We used to check if the context of FNDECL was different from
10865      current_class_type as another way to get inside here.  This didn't work
10866      for String.cc in libg++.  */
10867   if (DECL_FRIEND_P (fndecl))
10868     {
10869       VEC_safe_push (tree, CLASSTYPE_INLINE_FRIENDS (current_class_type),
10870                      fndecl);
10871       decl = void_type_node;
10872     }
10873
10874   return decl;
10875 }
10876 \f
10877
10878 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
10879    we can lay it out later, when and if its type becomes complete.  */
10880
10881 void
10882 maybe_register_incomplete_var (tree var)
10883 {
10884   gcc_assert (TREE_CODE (var) == VAR_DECL);
10885
10886   /* Keep track of variables with incomplete types.  */
10887   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
10888       && DECL_EXTERNAL (var))
10889     {
10890       tree inner_type = TREE_TYPE (var);
10891
10892       while (TREE_CODE (inner_type) == ARRAY_TYPE)
10893         inner_type = TREE_TYPE (inner_type);
10894       inner_type = TYPE_MAIN_VARIANT (inner_type);
10895
10896       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
10897           /* RTTI TD entries are created while defining the type_info.  */
10898           || (TYPE_LANG_SPECIFIC (inner_type)
10899               && TYPE_BEING_DEFINED (inner_type)))
10900         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
10901     }
10902 }
10903
10904 /* Called when a class type (given by TYPE) is defined.  If there are
10905    any existing VAR_DECLs whose type hsa been completed by this
10906    declaration, update them now.  */
10907
10908 void
10909 complete_vars (tree type)
10910 {
10911   tree *list = &incomplete_vars;
10912
10913   gcc_assert (CLASS_TYPE_P (type));
10914   while (*list)
10915     {
10916       if (same_type_p (type, TREE_PURPOSE (*list)))
10917         {
10918           tree var = TREE_VALUE (*list);
10919           tree type = TREE_TYPE (var);
10920           /* Complete the type of the variable.  The VAR_DECL itself
10921              will be laid out in expand_expr.  */
10922           complete_type (type);
10923           cp_apply_type_quals_to_decl (cp_type_quals (type), var);
10924           /* Remove this entry from the list.  */
10925           *list = TREE_CHAIN (*list);
10926         }
10927       else
10928         list = &TREE_CHAIN (*list);
10929     }
10930
10931   /* Check for pending declarations which may have abstract type.  */
10932   complete_type_check_abstract (type);
10933 }
10934
10935 /* If DECL is of a type which needs a cleanup, build that cleanup
10936    here.  */
10937
10938 tree
10939 cxx_maybe_build_cleanup (tree decl)
10940 {
10941   tree type = TREE_TYPE (decl);
10942
10943   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
10944     {
10945       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
10946       tree rval;
10947       bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
10948                          && CLASSTYPE_VBASECLASSES (type));
10949
10950       if (TREE_CODE (type) == ARRAY_TYPE)
10951         rval = decl;
10952       else
10953         {
10954           cxx_mark_addressable (decl);
10955           rval = build_unary_op (ADDR_EXPR, decl, 0);
10956         }
10957
10958       /* Optimize for space over speed here.  */
10959       if (!has_vbases || flag_expensive_optimizations)
10960         flags |= LOOKUP_NONVIRTUAL;
10961
10962       rval = build_delete (TREE_TYPE (rval), rval,
10963                            sfk_complete_destructor, flags, 0);
10964
10965       return rval;
10966     }
10967   return NULL_TREE;
10968 }
10969 \f
10970 /* When a stmt has been parsed, this function is called.  */
10971
10972 void
10973 finish_stmt (void)
10974 {
10975 }
10976
10977 /* DECL was originally constructed as a non-static member function,
10978    but turned out to be static.  Update it accordingly.  */
10979
10980 void
10981 revert_static_member_fn (tree decl)
10982 {
10983   tree tmp;
10984   tree function = TREE_TYPE (decl);
10985   tree args = TYPE_ARG_TYPES (function);
10986
10987   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
10988       != TYPE_UNQUALIFIED)
10989     error ("static member function %q#D declared with type qualifiers", decl);
10990
10991   args = TREE_CHAIN (args);
10992   tmp = build_function_type (TREE_TYPE (function), args);
10993   tmp = build_qualified_type (tmp, cp_type_quals (function));
10994   tmp = build_exception_variant (tmp,
10995                                  TYPE_RAISES_EXCEPTIONS (function));
10996   TREE_TYPE (decl) = tmp;
10997   if (DECL_ARGUMENTS (decl))
10998     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
10999   DECL_STATIC_FUNCTION_P (decl) = 1;
11000 }
11001
11002 /* Initialize the variables used during compilation of a C++
11003    function.  */
11004
11005 void
11006 cxx_push_function_context (struct function * f)
11007 {
11008   struct language_function *p = GGC_CNEW (struct language_function);
11009   f->language = p;
11010
11011   /* Whenever we start a new function, we destroy temporaries in the
11012      usual way.  */
11013   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11014
11015   if (f->decl)
11016     {
11017       tree fn = f->decl;
11018
11019       if (DECL_SAVED_FUNCTION_DATA (fn))
11020         {
11021           /* If we already parsed this function, and we're just expanding it
11022              now, restore saved state.  */
11023           *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
11024
11025           /* We don't need the saved data anymore.  Unless this is an inline
11026              function; we need the named return value info for
11027              declare_return_variable.  */
11028           if (! DECL_INLINE (fn))
11029             DECL_SAVED_FUNCTION_DATA (fn) = NULL;
11030         }
11031     }
11032 }
11033
11034 /* Free the language-specific parts of F, now that we've finished
11035    compiling the function.  */
11036
11037 void
11038 cxx_pop_function_context (struct function * f)
11039 {
11040   f->language = 0;
11041 }
11042
11043 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
11044    one of the language-independent trees.  */
11045
11046 enum cp_tree_node_structure_enum
11047 cp_tree_node_structure (union lang_tree_node * t)
11048 {
11049   switch (TREE_CODE (&t->generic))
11050     {
11051     case DEFAULT_ARG:           return TS_CP_DEFAULT_ARG;
11052     case IDENTIFIER_NODE:       return TS_CP_IDENTIFIER;
11053     case OVERLOAD:              return TS_CP_OVERLOAD;
11054     case TEMPLATE_PARM_INDEX:   return TS_CP_TPI;
11055     case TINST_LEVEL:           return TS_CP_TINST_LEVEL;
11056     case PTRMEM_CST:            return TS_CP_PTRMEM;
11057     case BASELINK:              return TS_CP_BASELINK;
11058     default:                    return TS_CP_GENERIC;
11059     }
11060 }
11061
11062 /* Build the void_list_node (void_type_node having been created).  */
11063 tree
11064 build_void_list_node (void)
11065 {
11066   tree t = build_tree_list (NULL_TREE, void_type_node);
11067   return t;
11068 }
11069
11070 bool
11071 cp_missing_noreturn_ok_p (tree decl)
11072 {
11073   /* A missing noreturn is ok for the `main' function.  */
11074   return DECL_MAIN_P (decl);
11075 }
11076
11077 /* Return the COMDAT group into which DECL should be placed.  */
11078
11079 const char *
11080 cxx_comdat_group (tree decl)
11081 {
11082   tree name;
11083
11084   /* Virtual tables, construction virtual tables, and virtual table
11085      tables all go in a single COMDAT group, named after the primary
11086      virtual table.  */
11087   if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
11088     name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
11089   /* For all other DECLs, the COMDAT group is the mangled name of the
11090      declaration itself.  */
11091   else
11092     {
11093       while (DECL_THUNK_P (decl))
11094         {
11095           /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
11096              into the same section as the target function.  In that case
11097              we must return target's name.  */
11098           tree target = THUNK_TARGET (decl);
11099           if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
11100               && DECL_SECTION_NAME (target) != NULL
11101               && DECL_ONE_ONLY (target))
11102             decl = target;
11103           else
11104             break;
11105         }
11106       name = DECL_ASSEMBLER_NAME (decl);
11107     }
11108
11109   return IDENTIFIER_POINTER (name);
11110 }
11111
11112 #include "gt-cp-decl.h"