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