gcc/cp/decl.c

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