gcc/cp/init.c

   1 /* Handle initialization things in C++.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 /* High-level class interface.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "tm.h"
  29 #include "tree.h"
  30 #include "cp-tree.h"
  31 #include "flags.h"
  32 #include "output.h"
  33 #include "toplev.h"
  34 #include "target.h"
  35
  36 static bool begin_init_stmts (tree *, tree *);
  37 static tree finish_init_stmts (bool, tree, tree);
  38 static void construct_virtual_base (tree, tree);
  39 static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t);
  40 static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t);
  41 static tree build_vec_delete_1 (tree, tree, tree, special_function_kind, int);
  42 static void perform_member_init (tree, tree);
  43 static tree build_builtin_delete_call (tree);
  44 static int member_init_ok_or_else (tree, tree, tree);
  45 static void expand_virtual_init (tree, tree);
  46 static tree sort_mem_initializers (tree, tree);
  47 static tree initializing_context (tree);
  48 static void expand_cleanup_for_base (tree, tree);
  49 static tree get_temp_regvar (tree, tree);
  50 static tree dfs_initialize_vtbl_ptrs (tree, void *);
  51 static tree build_dtor_call (tree, special_function_kind, int);
  52 static tree build_field_list (tree, tree, int *);
  53 static tree build_vtbl_address (tree);
  54 static int diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool, bool);
  55
  56 /* We are about to generate some complex initialization code.
  57    Conceptually, it is all a single expression.  However, we may want
  58    to include conditionals, loops, and other such statement-level
  59    constructs.  Therefore, we build the initialization code inside a
  60    statement-expression.  This function starts such an expression.
  61    STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
  62    pass them back to finish_init_stmts when the expression is
  63    complete.  */
  64
  65 static bool
  66 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
  67 {
  68   bool is_global = !building_stmt_tree ();
  69
  70   *stmt_expr_p = begin_stmt_expr ();
  71   *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
  72
  73   return is_global;
  74 }
  75
  76 /* Finish out the statement-expression begun by the previous call to
  77    begin_init_stmts.  Returns the statement-expression itself.  */
  78
  79 static tree
  80 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
  81 {
  82   finish_compound_stmt (compound_stmt);
  83
  84   stmt_expr = finish_stmt_expr (stmt_expr, true);
  85
  86   gcc_assert (!building_stmt_tree () == is_global);
  87
  88   return stmt_expr;
  89 }
  90
  91 /* Constructors */
  92
  93 /* Called from initialize_vtbl_ptrs via dfs_walk.  BINFO is the base
  94    which we want to initialize the vtable pointer for, DATA is
  95    TREE_LIST whose TREE_VALUE is the this ptr expression.  */
  96
  97 static tree
  98 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
  99 {
 100   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
 101     return dfs_skip_bases;
 102
 103   if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
 104     {
 105       tree base_ptr = TREE_VALUE ((tree) data);
 106
 107       base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
 108
 109       expand_virtual_init (binfo, base_ptr);
 110     }
 111
 112   return NULL_TREE;
 113 }
 114
 115 /* Initialize all the vtable pointers in the object pointed to by
 116    ADDR.  */
 117
 118 void
 119 initialize_vtbl_ptrs (tree addr)
 120 {
 121   tree list;
 122   tree type;
 123
 124   type = TREE_TYPE (TREE_TYPE (addr));
 125   list = build_tree_list (type, addr);
 126
 127   /* Walk through the hierarchy, initializing the vptr in each base
 128      class.  We do these in pre-order because we can't find the virtual
 129      bases for a class until we've initialized the vtbl for that
 130      class.  */
 131   dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
 132 }
 133
 134 /* Return an expression for the zero-initialization of an object with
 135    type T.  This expression will either be a constant (in the case
 136    that T is a scalar), or a CONSTRUCTOR (in the case that T is an
 137    aggregate), or NULL (in the case that T does not require
 138    initialization).  In either case, the value can be used as
 139    DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
 140    initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
 141    is the number of elements in the array.  If STATIC_STORAGE_P is
 142    TRUE, initializers are only generated for entities for which
 143    zero-initialization does not simply mean filling the storage with
 144    zero bytes.  */
 145
 146 tree
 147 build_zero_init (tree type, tree nelts, bool static_storage_p)
 148 {
 149   tree init = NULL_TREE;
 150
 151   /* [dcl.init]
 152
 153      To zero-initialize an object of type T means:
 154
 155      -- if T is a scalar type, the storage is set to the value of zero
 156         converted to T.
 157
 158      -- if T is a non-union class type, the storage for each nonstatic
 159         data member and each base-class subobject is zero-initialized.
 160
 161      -- if T is a union type, the storage for its first data member is
 162         zero-initialized.
 163
 164      -- if T is an array type, the storage for each element is
 165         zero-initialized.
 166
 167      -- if T is a reference type, no initialization is performed.  */
 168
 169   gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
 170
 171   if (type == error_mark_node)
 172     ;
 173   else if (static_storage_p && zero_init_p (type))
 174     /* In order to save space, we do not explicitly build initializers
 175        for items that do not need them.  GCC's semantics are that
 176        items with static storage duration that are not otherwise
 177        initialized are initialized to zero.  */
 178     ;
 179   else if (SCALAR_TYPE_P (type))
 180     init = convert (type, integer_zero_node);
 181   else if (CLASS_TYPE_P (type))
 182     {
 183       tree field;
 184       VEC(constructor_elt,gc) *v = NULL;
 185
 186       /* Iterate over the fields, building initializations.  */
 187       for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
 188         {
 189           if (TREE_CODE (field) != FIELD_DECL)
 190             continue;
 191
 192           /* Note that for class types there will be FIELD_DECLs
 193              corresponding to base classes as well.  Thus, iterating
 194              over TYPE_FIELDs will result in correct initialization of
 195              all of the subobjects.  */
 196           if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
 197             {
 198               tree value = build_zero_init (TREE_TYPE (field),
 199                                             /*nelts=*/NULL_TREE,
 200                                             static_storage_p);
 201               if (value)
 202                 CONSTRUCTOR_APPEND_ELT(v, field, value);
 203             }
 204
 205           /* For unions, only the first field is initialized.  */
 206           if (TREE_CODE (type) == UNION_TYPE)
 207             break;
 208         }
 209
 210       /* Build a constructor to contain the initializations.  */
 211       init = build_constructor (type, v);
 212     }
 213   else if (TREE_CODE (type) == ARRAY_TYPE)
 214     {
 215       tree max_index;
 216       VEC(constructor_elt,gc) *v = NULL;
 217
 218       /* Iterate over the array elements, building initializations.  */
 219       if (nelts)
 220         max_index = fold_build2_loc (input_location,
 221                                  MINUS_EXPR, TREE_TYPE (nelts),
 222                                  nelts, integer_one_node);
 223       else
 224         max_index = array_type_nelts (type);
 225
 226       /* If we have an error_mark here, we should just return error mark
 227          as we don't know the size of the array yet.  */
 228       if (max_index == error_mark_node)
 229         return error_mark_node;
 230       gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
 231
 232       /* A zero-sized array, which is accepted as an extension, will
 233          have an upper bound of -1.  */
 234       if (!tree_int_cst_equal (max_index, integer_minus_one_node))
 235         {
 236           constructor_elt *ce;
 237
 238           v = VEC_alloc (constructor_elt, gc, 1);
 239           ce = VEC_quick_push (constructor_elt, v, NULL);
 240
 241           /* If this is a one element array, we just use a regular init.  */
 242           if (tree_int_cst_equal (size_zero_node, max_index))
 243             ce->index = size_zero_node;
 244           else
 245             ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
 246                                 max_index);
 247
 248           ce->value = build_zero_init (TREE_TYPE (type),
 249                                        /*nelts=*/NULL_TREE,
 250                                        static_storage_p);
 251         }
 252
 253       /* Build a constructor to contain the initializations.  */
 254       init = build_constructor (type, v);
 255     }
 256   else if (TREE_CODE (type) == VECTOR_TYPE)
 257     init = build_zero_cst (type);
 258   else
 259     gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
 260
 261   /* In all cases, the initializer is a constant.  */
 262   if (init)
 263     TREE_CONSTANT (init) = 1;
 264
 265   return init;
 266 }
 267
 268 /* Return a suitable initializer for value-initializing an object of type
 269    TYPE, as described in [dcl.init].  */
 270
 271 tree
 272 build_value_init (tree type, tsubst_flags_t complain)
 273 {
 274   /* [dcl.init]
 275
 276      To value-initialize an object of type T means:
 277
 278      - if T is a class type (clause 9) with a user-provided constructor
 279        (12.1), then the default constructor for T is called (and the
 280        initialization is ill-formed if T has no accessible default
 281        constructor);
 282
 283      - if T is a non-union class type without a user-provided constructor,
 284        then every non-static data member and base-class component of T is
 285        value-initialized;92)
 286
 287      - if T is an array type, then each element is value-initialized;
 288
 289      - otherwise, the object is zero-initialized.
 290
 291      A program that calls for default-initialization or
 292      value-initialization of an entity of reference type is ill-formed.
 293
 294      92) Value-initialization for such a class object may be implemented by
 295      zero-initializing the object and then calling the default
 296      constructor.  */
 297
 298   /* The AGGR_INIT_EXPR tweaking below breaks in templates.  */
 299   gcc_assert (!processing_template_decl);
 300
 301   if (CLASS_TYPE_P (type))
 302     {
 303       if (type_has_user_provided_constructor (type))
 304         return build_aggr_init_expr
 305           (type,
 306            build_special_member_call (NULL_TREE, complete_ctor_identifier,
 307                                       NULL, type, LOOKUP_NORMAL,
 308                                       complain));
 309       else if (TREE_CODE (type) != UNION_TYPE && TYPE_NEEDS_CONSTRUCTING (type))
 310         {
 311           /* This is a class that needs constructing, but doesn't have
 312              a user-provided constructor.  So we need to zero-initialize
 313              the object and then call the implicitly defined ctor.
 314              This will be handled in simplify_aggr_init_expr.  */
 315           tree ctor = build_special_member_call
 316             (NULL_TREE, complete_ctor_identifier,
 317              NULL, type, LOOKUP_NORMAL, complain);
 318
 319           ctor = build_aggr_init_expr (type, ctor);
 320           AGGR_INIT_ZERO_FIRST (ctor) = 1;
 321           return ctor;
 322         }
 323     }
 324   return build_value_init_noctor (type, complain);
 325 }
 326
 327 /* Like build_value_init, but don't call the constructor for TYPE.  Used
 328    for base initializers.  */
 329
 330 tree
 331 build_value_init_noctor (tree type, tsubst_flags_t complain)
 332 {
 333   if (CLASS_TYPE_P (type))
 334     {
 335       gcc_assert (!TYPE_NEEDS_CONSTRUCTING (type));
 336
 337       if (TREE_CODE (type) != UNION_TYPE)
 338         {
 339           tree field;
 340           VEC(constructor_elt,gc) *v = NULL;
 341
 342           /* Iterate over the fields, building initializations.  */
 343           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
 344             {
 345               tree ftype, value;
 346
 347               if (TREE_CODE (field) != FIELD_DECL)
 348                 continue;
 349
 350               ftype = TREE_TYPE (field);
 351
 352               if (TREE_CODE (ftype) == REFERENCE_TYPE)
 353                 {
 354                   if (complain & tf_error)
 355                     error ("value-initialization of reference");
 356                   else
 357                     return error_mark_node;
 358                 }
 359
 360               /* We could skip vfields and fields of types with
 361                  user-defined constructors, but I think that won't improve
 362                  performance at all; it should be simpler in general just
 363                  to zero out the entire object than try to only zero the
 364                  bits that actually need it.  */
 365
 366               /* Note that for class types there will be FIELD_DECLs
 367                  corresponding to base classes as well.  Thus, iterating
 368                  over TYPE_FIELDs will result in correct initialization of
 369                  all of the subobjects.  */
 370               value = build_value_init (ftype, complain);
 371
 372               if (value)
 373                 CONSTRUCTOR_APPEND_ELT(v, field, value);
 374             }
 375
 376           /* Build a constructor to contain the zero- initializations.  */
 377           return build_constructor (type, v);
 378         }
 379     }
 380   else if (TREE_CODE (type) == ARRAY_TYPE)
 381     {
 382       VEC(constructor_elt,gc) *v = NULL;
 383
 384       /* Iterate over the array elements, building initializations.  */
 385       tree max_index = array_type_nelts (type);
 386
 387       /* If we have an error_mark here, we should just return error mark
 388          as we don't know the size of the array yet.  */
 389       if (max_index == error_mark_node)
 390         {
 391           error ("cannot value-initialize array of unknown bound %qT", type);
 392           return error_mark_node;
 393         }
 394       gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
 395
 396       /* A zero-sized array, which is accepted as an extension, will
 397          have an upper bound of -1.  */
 398       if (!tree_int_cst_equal (max_index, integer_minus_one_node))
 399         {
 400           constructor_elt *ce;
 401
 402           v = VEC_alloc (constructor_elt, gc, 1);
 403           ce = VEC_quick_push (constructor_elt, v, NULL);
 404
 405           /* If this is a one element array, we just use a regular init.  */
 406           if (tree_int_cst_equal (size_zero_node, max_index))
 407             ce->index = size_zero_node;
 408           else
 409             ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
 410                                 max_index);
 411
 412           ce->value = build_value_init (TREE_TYPE (type), complain);
 413
 414           /* The gimplifier can't deal with a RANGE_EXPR of TARGET_EXPRs.  */
 415           gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
 416                       && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
 417         }
 418
 419       /* Build a constructor to contain the initializations.  */
 420       return build_constructor (type, v);
 421     }
 422
 423   return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
 424 }
 425
 426 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
 427    arguments.  If TREE_LIST is void_type_node, an empty initializer
 428    list was given; if NULL_TREE no initializer was given.  */
 429
 430 static void
 431 perform_member_init (tree member, tree init)
 432 {
 433   tree decl;
 434   tree type = TREE_TYPE (member);
 435
 436   /* Effective C++ rule 12 requires that all data members be
 437      initialized.  */
 438   if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
 439     warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,
 440                 "%qD should be initialized in the member initialization list",
 441                 member);
 442
 443   /* Get an lvalue for the data member.  */
 444   decl = build_class_member_access_expr (current_class_ref, member,
 445                                          /*access_path=*/NULL_TREE,
 446                                          /*preserve_reference=*/true,
 447                                          tf_warning_or_error);
 448   if (decl == error_mark_node)
 449     return;
 450
 451   if (init == void_type_node)
 452     {
 453       /* mem() means value-initialization.  */
 454       if (TREE_CODE (type) == ARRAY_TYPE)
 455         {
 456           init = build_vec_init (decl, NULL_TREE, NULL_TREE,
 457                                  /*explicit_value_init_p=*/true,
 458                                  /* from_array=*/0,
 459                                  tf_warning_or_error);
 460           finish_expr_stmt (init);
 461         }
 462       else
 463         {
 464           if (TREE_CODE (type) == REFERENCE_TYPE)
 465             permerror (DECL_SOURCE_LOCATION (current_function_decl),
 466                        "value-initialization of %q#D, which has reference type",
 467                        member);
 468           else
 469             {
 470               init = build2 (INIT_EXPR, type, decl,
 471                              build_value_init (type, tf_warning_or_error));
 472               finish_expr_stmt (init);
 473             }
 474         }
 475     }
 476   /* Deal with this here, as we will get confused if we try to call the
 477      assignment op for an anonymous union.  This can happen in a
 478      synthesized copy constructor.  */
 479   else if (ANON_AGGR_TYPE_P (type))
 480     {
 481       if (init)
 482         {
 483           init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
 484           finish_expr_stmt (init);
 485         }
 486     }
 487   else if (TYPE_NEEDS_CONSTRUCTING (type))
 488     {
 489       if (TREE_CODE (type) == ARRAY_TYPE)
 490         {
 491           if (init)
 492             {
 493               gcc_assert (TREE_CHAIN (init) == NULL_TREE);
 494               init = TREE_VALUE (init);
 495             }
 496           if (init == NULL_TREE
 497               || same_type_ignoring_top_level_qualifiers_p (type,
 498                                                             TREE_TYPE (init)))
 499             {
 500               init = build_vec_init_expr (type, init);
 501               init = build2 (INIT_EXPR, type, decl, init);
 502               finish_expr_stmt (init);
 503             }
 504           else
 505             error ("invalid initializer for array member %q#D", member);
 506         }
 507       else
 508         {
 509           if (CP_TYPE_CONST_P (type)
 510               && init == NULL_TREE
 511               && !type_has_user_provided_default_constructor (type))
 512             /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
 513                vtable; still give this diagnostic.  */
 514             permerror (DECL_SOURCE_LOCATION (current_function_decl),
 515                        "uninitialized member %qD with %<const%> type %qT",
 516                        member, type);
 517           finish_expr_stmt (build_aggr_init (decl, init, 0,
 518                                              tf_warning_or_error));
 519         }
 520     }
 521   else
 522     {
 523       if (init == NULL_TREE)
 524         {
 525           tree core_type;
 526           /* member traversal: note it leaves init NULL */
 527           if (TREE_CODE (type) == REFERENCE_TYPE)
 528             permerror (DECL_SOURCE_LOCATION (current_function_decl),
 529                        "uninitialized reference member %qD",
 530                        member);
 531           else if (CP_TYPE_CONST_P (type))
 532             permerror (DECL_SOURCE_LOCATION (current_function_decl),
 533                        "uninitialized member %qD with %<const%> type %qT",
 534                        member, type);
 535
 536           if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)
 537               && !type_has_constexpr_default_constructor (type))
 538             {
 539               if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl))
 540                 error ("uninitialized member %qD in %<constexpr%> constructor",
 541                        member);
 542               DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
 543             }
 544
 545           core_type = strip_array_types (type);
 546           if (CLASS_TYPE_P (core_type)
 547               && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
 548                   || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
 549             diagnose_uninitialized_cst_or_ref_member (core_type,
 550                                                       /*using_new=*/false,
 551                                                       /*complain=*/true);
 552         }
 553       else if (TREE_CODE (init) == TREE_LIST)
 554         /* There was an explicit member initialization.  Do some work
 555            in that case.  */
 556         init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,
 557                                                 tf_warning_or_error);
 558
 559       if (init)
 560         finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
 561                                                 tf_warning_or_error));
 562     }
 563
 564   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
 565     {
 566       tree expr;
 567
 568       expr = build_class_member_access_expr (current_class_ref, member,
 569                                              /*access_path=*/NULL_TREE,
 570                                              /*preserve_reference=*/false,
 571                                              tf_warning_or_error);
 572       expr = build_delete (type, expr, sfk_complete_destructor,
 573                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
 574
 575       if (expr != error_mark_node)
 576         finish_eh_cleanup (expr);
 577     }
 578 }
 579
 580 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
 581    the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order.  */
 582
 583 static tree
 584 build_field_list (tree t, tree list, int *uses_unions_p)
 585 {
 586   tree fields;
 587
 588   *uses_unions_p = 0;
 589
 590   /* Note whether or not T is a union.  */
 591   if (TREE_CODE (t) == UNION_TYPE)
 592     *uses_unions_p = 1;
 593
 594   for (fields = TYPE_FIELDS (t); fields; fields = DECL_CHAIN (fields))
 595     {
 596       tree fieldtype;
 597
 598       /* Skip CONST_DECLs for enumeration constants and so forth.  */
 599       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 600         continue;
 601
 602       fieldtype = TREE_TYPE (fields);
 603       /* Keep track of whether or not any fields are unions.  */
 604       if (TREE_CODE (fieldtype) == UNION_TYPE)
 605         *uses_unions_p = 1;
 606
 607       /* For an anonymous struct or union, we must recursively
 608          consider the fields of the anonymous type.  They can be
 609          directly initialized from the constructor.  */
 610       if (ANON_AGGR_TYPE_P (fieldtype))
 611         {
 612           /* Add this field itself.  Synthesized copy constructors
 613              initialize the entire aggregate.  */
 614           list = tree_cons (fields, NULL_TREE, list);
 615           /* And now add the fields in the anonymous aggregate.  */
 616           list = build_field_list (fieldtype, list, uses_unions_p);
 617         }
 618       /* Add this field.  */
 619       else if (DECL_NAME (fields))
 620         list = tree_cons (fields, NULL_TREE, list);
 621     }
 622
 623   return list;
 624 }
 625
 626 /* The MEM_INITS are a TREE_LIST.  The TREE_PURPOSE of each list gives
 627    a FIELD_DECL or BINFO in T that needs initialization.  The
 628    TREE_VALUE gives the initializer, or list of initializer arguments.
 629
 630    Return a TREE_LIST containing all of the initializations required
 631    for T, in the order in which they should be performed.  The output
 632    list has the same format as the input.  */
 633
 634 static tree
 635 sort_mem_initializers (tree t, tree mem_inits)
 636 {
 637   tree init;
 638   tree base, binfo, base_binfo;
 639   tree sorted_inits;
 640   tree next_subobject;
 641   VEC(tree,gc) *vbases;
 642   int i;
 643   int uses_unions_p;
 644
 645   /* Build up a list of initializations.  The TREE_PURPOSE of entry
 646      will be the subobject (a FIELD_DECL or BINFO) to initialize.  The
 647      TREE_VALUE will be the constructor arguments, or NULL if no
 648      explicit initialization was provided.  */
 649   sorted_inits = NULL_TREE;
 650
 651   /* Process the virtual bases.  */
 652   for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
 653        VEC_iterate (tree, vbases, i, base); i++)
 654     sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
 655
 656   /* Process the direct bases.  */
 657   for (binfo = TYPE_BINFO (t), i = 0;
 658        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
 659     if (!BINFO_VIRTUAL_P (base_binfo))
 660       sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
 661
 662   /* Process the non-static data members.  */
 663   sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
 664   /* Reverse the entire list of initializations, so that they are in
 665      the order that they will actually be performed.  */
 666   sorted_inits = nreverse (sorted_inits);
 667
 668   /* If the user presented the initializers in an order different from
 669      that in which they will actually occur, we issue a warning.  Keep
 670      track of the next subobject which can be explicitly initialized
 671      without issuing a warning.  */
 672   next_subobject = sorted_inits;
 673
 674   /* Go through the explicit initializers, filling in TREE_PURPOSE in
 675      the SORTED_INITS.  */
 676   for (init = mem_inits; init; init = TREE_CHAIN (init))
 677     {
 678       tree subobject;
 679       tree subobject_init;
 680
 681       subobject = TREE_PURPOSE (init);
 682
 683       /* If the explicit initializers are in sorted order, then
 684          SUBOBJECT will be NEXT_SUBOBJECT, or something following
 685          it.  */
 686       for (subobject_init = next_subobject;
 687            subobject_init;
 688            subobject_init = TREE_CHAIN (subobject_init))
 689         if (TREE_PURPOSE (subobject_init) == subobject)
 690           break;
 691
 692       /* Issue a warning if the explicit initializer order does not
 693          match that which will actually occur.
 694          ??? Are all these on the correct lines?  */
 695       if (warn_reorder && !subobject_init)
 696         {
 697           if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
 698             warning (OPT_Wreorder, "%q+D will be initialized after",
 699                      TREE_PURPOSE (next_subobject));
 700           else
 701             warning (OPT_Wreorder, "base %qT will be initialized after",
 702                      TREE_PURPOSE (next_subobject));
 703           if (TREE_CODE (subobject) == FIELD_DECL)
 704             warning (OPT_Wreorder, "  %q+#D", subobject);
 705           else
 706             warning (OPT_Wreorder, "  base %qT", subobject);
 707           warning_at (DECL_SOURCE_LOCATION (current_function_decl),
 708                       OPT_Wreorder, "  when initialized here");
 709         }
 710
 711       /* Look again, from the beginning of the list.  */
 712       if (!subobject_init)
 713         {
 714           subobject_init = sorted_inits;
 715           while (TREE_PURPOSE (subobject_init) != subobject)
 716             subobject_init = TREE_CHAIN (subobject_init);
 717         }
 718
 719       /* It is invalid to initialize the same subobject more than
 720          once.  */
 721       if (TREE_VALUE (subobject_init))
 722         {
 723           if (TREE_CODE (subobject) == FIELD_DECL)
 724             error_at (DECL_SOURCE_LOCATION (current_function_decl),
 725                       "multiple initializations given for %qD",
 726                       subobject);
 727           else
 728             error_at (DECL_SOURCE_LOCATION (current_function_decl),
 729                       "multiple initializations given for base %qT",
 730                       subobject);
 731         }
 732
 733       /* Record the initialization.  */
 734       TREE_VALUE (subobject_init) = TREE_VALUE (init);
 735       next_subobject = subobject_init;
 736     }
 737
 738   /* [class.base.init]
 739
 740      If a ctor-initializer specifies more than one mem-initializer for
 741      multiple members of the same union (including members of
 742      anonymous unions), the ctor-initializer is ill-formed.
 743
 744      Here we also splice out uninitialized union members.  */
 745   if (uses_unions_p)
 746     {
 747       tree last_field = NULL_TREE;
 748       tree *p;
 749       for (p = &sorted_inits; *p; )
 750         {
 751           tree field;
 752           tree ctx;
 753           int done;
 754
 755           init = *p;
 756
 757           field = TREE_PURPOSE (init);
 758
 759           /* Skip base classes.  */
 760           if (TREE_CODE (field) != FIELD_DECL)
 761             goto next;
 762
 763           /* If this is an anonymous union with no explicit initializer,
 764              splice it out.  */
 765           if (!TREE_VALUE (init) && ANON_UNION_TYPE_P (TREE_TYPE (field)))
 766             goto splice;
 767
 768           /* See if this field is a member of a union, or a member of a
 769              structure contained in a union, etc.  */
 770           for (ctx = DECL_CONTEXT (field);
 771                !same_type_p (ctx, t);
 772                ctx = TYPE_CONTEXT (ctx))
 773             if (TREE_CODE (ctx) == UNION_TYPE)
 774               break;
 775           /* If this field is not a member of a union, skip it.  */
 776           if (TREE_CODE (ctx) != UNION_TYPE)
 777             goto next;
 778
 779           /* If this union member has no explicit initializer, splice
 780              it out.  */
 781           if (!TREE_VALUE (init))
 782             goto splice;
 783
 784           /* It's only an error if we have two initializers for the same
 785              union type.  */
 786           if (!last_field)
 787             {
 788               last_field = field;
 789               goto next;
 790             }
 791
 792           /* See if LAST_FIELD and the field initialized by INIT are
 793              members of the same union.  If so, there's a problem,
 794              unless they're actually members of the same structure
 795              which is itself a member of a union.  For example, given:
 796
 797                union { struct { int i; int j; }; };
 798
 799              initializing both `i' and `j' makes sense.  */
 800           ctx = DECL_CONTEXT (field);
 801           done = 0;
 802           do
 803             {
 804               tree last_ctx;
 805
 806               last_ctx = DECL_CONTEXT (last_field);
 807               while (1)
 808                 {
 809                   if (same_type_p (last_ctx, ctx))
 810                     {
 811                       if (TREE_CODE (ctx) == UNION_TYPE)
 812                         error_at (DECL_SOURCE_LOCATION (current_function_decl),
 813                                   "initializations for multiple members of %qT",
 814                                   last_ctx);
 815                       done = 1;
 816                       break;
 817                     }
 818
 819                   if (same_type_p (last_ctx, t))
 820                     break;
 821
 822                   last_ctx = TYPE_CONTEXT (last_ctx);
 823                 }
 824
 825               /* If we've reached the outermost class, then we're
 826                  done.  */
 827               if (same_type_p (ctx, t))
 828                 break;
 829
 830               ctx = TYPE_CONTEXT (ctx);
 831             }
 832           while (!done);
 833
 834           last_field = field;
 835
 836         next:
 837           p = &TREE_CHAIN (*p);
 838           continue;
 839         splice:
 840           *p = TREE_CHAIN (*p);
 841           continue;
 842         }
 843     }
 844
 845   return sorted_inits;
 846 }
 847
 848 /* Initialize all bases and members of CURRENT_CLASS_TYPE.  MEM_INITS
 849    is a TREE_LIST giving the explicit mem-initializer-list for the
 850    constructor.  The TREE_PURPOSE of each entry is a subobject (a
 851    FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE.  The TREE_VALUE
 852    is a TREE_LIST giving the arguments to the constructor or
 853    void_type_node for an empty list of arguments.  */
 854
 855 void
 856 emit_mem_initializers (tree mem_inits)
 857 {
 858   /* We will already have issued an error message about the fact that
 859      the type is incomplete.  */
 860   if (!COMPLETE_TYPE_P (current_class_type))
 861     return;
 862
 863   /* Sort the mem-initializers into the order in which the
 864      initializations should be performed.  */
 865   mem_inits = sort_mem_initializers (current_class_type, mem_inits);
 866
 867   in_base_initializer = 1;
 868
 869   /* Initialize base classes.  */
 870   while (mem_inits
 871          && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
 872     {
 873       tree subobject = TREE_PURPOSE (mem_inits);
 874       tree arguments = TREE_VALUE (mem_inits);
 875
 876       if (arguments == NULL_TREE)
 877         {
 878           /* If these initializations are taking place in a copy constructor,
 879              the base class should probably be explicitly initialized if there
 880              is a user-defined constructor in the base class (other than the
 881              default constructor, which will be called anyway).  */
 882           if (extra_warnings
 883               && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
 884               && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
 885             warning_at (DECL_SOURCE_LOCATION (current_function_decl),
 886                         OPT_Wextra, "base class %q#T should be explicitly "
 887                         "initialized in the copy constructor",
 888                         BINFO_TYPE (subobject));
 889
 890           if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)
 891               && !(type_has_constexpr_default_constructor
 892                    (BINFO_TYPE (subobject))))
 893             {
 894               if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl))
 895                 error ("uninitialized base %qT in %<constexpr%> constructor",
 896                        BINFO_TYPE (subobject));
 897               DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
 898             }
 899         }
 900
 901       /* Initialize the base.  */
 902       if (BINFO_VIRTUAL_P (subobject))
 903         construct_virtual_base (subobject, arguments);
 904       else
 905         {
 906           tree base_addr;
 907
 908           base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
 909                                        subobject, 1);
 910           expand_aggr_init_1 (subobject, NULL_TREE,
 911                               cp_build_indirect_ref (base_addr, RO_NULL,
 912                                                      tf_warning_or_error),
 913                               arguments,
 914                               LOOKUP_NORMAL,
 915                               tf_warning_or_error);
 916           expand_cleanup_for_base (subobject, NULL_TREE);
 917         }
 918
 919       mem_inits = TREE_CHAIN (mem_inits);
 920     }
 921   in_base_initializer = 0;
 922
 923   /* Initialize the vptrs.  */
 924   initialize_vtbl_ptrs (current_class_ptr);
 925
 926   /* Initialize the data members.  */
 927   while (mem_inits)
 928     {
 929       perform_member_init (TREE_PURPOSE (mem_inits),
 930                            TREE_VALUE (mem_inits));
 931       mem_inits = TREE_CHAIN (mem_inits);
 932     }
 933 }
 934
 935 /* Returns the address of the vtable (i.e., the value that should be
 936    assigned to the vptr) for BINFO.  */
 937
 938 static tree
 939 build_vtbl_address (tree binfo)
 940 {
 941   tree binfo_for = binfo;
 942   tree vtbl;
 943
 944   if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
 945     /* If this is a virtual primary base, then the vtable we want to store
 946        is that for the base this is being used as the primary base of.  We
 947        can't simply skip the initialization, because we may be expanding the
 948        inits of a subobject constructor where the virtual base layout
 949        can be different.  */
 950     while (BINFO_PRIMARY_P (binfo_for))
 951       binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
 952
 953   /* Figure out what vtable BINFO's vtable is based on, and mark it as
 954      used.  */
 955   vtbl = get_vtbl_decl_for_binfo (binfo_for);
 956   TREE_USED (vtbl) = 1;
 957
 958   /* Now compute the address to use when initializing the vptr.  */
 959   vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
 960   if (TREE_CODE (vtbl) == VAR_DECL)
 961     vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
 962
 963   return vtbl;
 964 }
 965
 966 /* This code sets up the virtual function tables appropriate for
 967    the pointer DECL.  It is a one-ply initialization.
 968
 969    BINFO is the exact type that DECL is supposed to be.  In
 970    multiple inheritance, this might mean "C's A" if C : A, B.  */
 971
 972 static void
 973 expand_virtual_init (tree binfo, tree decl)
 974 {
 975   tree vtbl, vtbl_ptr;
 976   tree vtt_index;
 977
 978   /* Compute the initializer for vptr.  */
 979   vtbl = build_vtbl_address (binfo);
 980
 981   /* We may get this vptr from a VTT, if this is a subobject
 982      constructor or subobject destructor.  */
 983   vtt_index = BINFO_VPTR_INDEX (binfo);
 984   if (vtt_index)
 985     {
 986       tree vtbl2;
 987       tree vtt_parm;
 988
 989       /* Compute the value to use, when there's a VTT.  */
 990       vtt_parm = current_vtt_parm;
 991       vtbl2 = build2 (POINTER_PLUS_EXPR,
 992                       TREE_TYPE (vtt_parm),
 993                       vtt_parm,
 994                       vtt_index);
 995       vtbl2 = cp_build_indirect_ref (vtbl2, RO_NULL, tf_warning_or_error);
 996       vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
 997
 998       /* The actual initializer is the VTT value only in the subobject
 999          constructor.  In maybe_clone_body we'll substitute NULL for
1000          the vtt_parm in the case of the non-subobject constructor.  */
1001       vtbl = build3 (COND_EXPR,
1002                      TREE_TYPE (vtbl),
1003                      build2 (EQ_EXPR, boolean_type_node,
1004                              current_in_charge_parm, integer_zero_node),
1005                      vtbl2,
1006                      vtbl);
1007     }
1008
1009   /* Compute the location of the vtpr.  */
1010   vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, RO_NULL,
1011                                                       tf_warning_or_error),
1012                                TREE_TYPE (binfo));
1013   gcc_assert (vtbl_ptr != error_mark_node);
1014
1015   /* Assign the vtable to the vptr.  */
1016   vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
1017   finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
1018                                           tf_warning_or_error));
1019 }
1020
1021 /* If an exception is thrown in a constructor, those base classes already
1022    constructed must be destroyed.  This function creates the cleanup
1023    for BINFO, which has just been constructed.  If FLAG is non-NULL,
1024    it is a DECL which is nonzero when this base needs to be
1025    destroyed.  */
1026
1027 static void
1028 expand_cleanup_for_base (tree binfo, tree flag)
1029 {
1030   tree expr;
1031
1032   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
1033     return;
1034
1035   /* Call the destructor.  */
1036   expr = build_special_member_call (current_class_ref,
1037                                     base_dtor_identifier,
1038                                     NULL,
1039                                     binfo,
1040                                     LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
1041                                     tf_warning_or_error);
1042   if (flag)
1043     expr = fold_build3_loc (input_location,
1044                         COND_EXPR, void_type_node,
1045                         c_common_truthvalue_conversion (input_location, flag),
1046                         expr, integer_zero_node);
1047
1048   finish_eh_cleanup (expr);
1049 }
1050
1051 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1052    constructor.  */
1053
1054 static void
1055 construct_virtual_base (tree vbase, tree arguments)
1056 {
1057   tree inner_if_stmt;
1058   tree exp;
1059   tree flag;
1060
1061   /* If there are virtual base classes with destructors, we need to
1062      emit cleanups to destroy them if an exception is thrown during
1063      the construction process.  These exception regions (i.e., the
1064      period during which the cleanups must occur) begin from the time
1065      the construction is complete to the end of the function.  If we
1066      create a conditional block in which to initialize the
1067      base-classes, then the cleanup region for the virtual base begins
1068      inside a block, and ends outside of that block.  This situation
1069      confuses the sjlj exception-handling code.  Therefore, we do not
1070      create a single conditional block, but one for each
1071      initialization.  (That way the cleanup regions always begin
1072      in the outer block.)  We trust the back end to figure out
1073      that the FLAG will not change across initializations, and
1074      avoid doing multiple tests.  */
1075   flag = DECL_CHAIN (DECL_ARGUMENTS (current_function_decl));
1076   inner_if_stmt = begin_if_stmt ();
1077   finish_if_stmt_cond (flag, inner_if_stmt);
1078
1079   /* Compute the location of the virtual base.  If we're
1080      constructing virtual bases, then we must be the most derived
1081      class.  Therefore, we don't have to look up the virtual base;
1082      we already know where it is.  */
1083   exp = convert_to_base_statically (current_class_ref, vbase);
1084
1085   expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1086                       LOOKUP_COMPLAIN, tf_warning_or_error);
1087   finish_then_clause (inner_if_stmt);
1088   finish_if_stmt (inner_if_stmt);
1089
1090   expand_cleanup_for_base (vbase, flag);
1091 }
1092
1093 /* Find the context in which this FIELD can be initialized.  */
1094
1095 static tree
1096 initializing_context (tree field)
1097 {
1098   tree t = DECL_CONTEXT (field);
1099
1100   /* Anonymous union members can be initialized in the first enclosing
1101      non-anonymous union context.  */
1102   while (t && ANON_AGGR_TYPE_P (t))
1103     t = TYPE_CONTEXT (t);
1104   return t;
1105 }
1106
1107 /* Function to give error message if member initialization specification
1108    is erroneous.  FIELD is the member we decided to initialize.
1109    TYPE is the type for which the initialization is being performed.
1110    FIELD must be a member of TYPE.
1111
1112    MEMBER_NAME is the name of the member.  */
1113
1114 static int
1115 member_init_ok_or_else (tree field, tree type, tree member_name)
1116 {
1117   if (field == error_mark_node)
1118     return 0;
1119   if (!field)
1120     {
1121       error ("class %qT does not have any field named %qD", type,
1122              member_name);
1123       return 0;
1124     }
1125   if (TREE_CODE (field) == VAR_DECL)
1126     {
1127       error ("%q#D is a static data member; it can only be "
1128              "initialized at its definition",
1129              field);
1130       return 0;
1131     }
1132   if (TREE_CODE (field) != FIELD_DECL)
1133     {
1134       error ("%q#D is not a non-static data member of %qT",
1135              field, type);
1136       return 0;
1137     }
1138   if (initializing_context (field) != type)
1139     {
1140       error ("class %qT does not have any field named %qD", type,
1141                 member_name);
1142       return 0;
1143     }
1144
1145   return 1;
1146 }
1147
1148 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1149    is a _TYPE node or TYPE_DECL which names a base for that type.
1150    Check the validity of NAME, and return either the base _TYPE, base
1151    binfo, or the FIELD_DECL of the member.  If NAME is invalid, return
1152    NULL_TREE and issue a diagnostic.
1153
1154    An old style unnamed direct single base construction is permitted,
1155    where NAME is NULL.  */
1156
1157 tree
1158 expand_member_init (tree name)
1159 {
1160   tree basetype;
1161   tree field;
1162
1163   if (!current_class_ref)
1164     return NULL_TREE;
1165
1166   if (!name)
1167     {
1168       /* This is an obsolete unnamed base class initializer.  The
1169          parser will already have warned about its use.  */
1170       switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1171         {
1172         case 0:
1173           error ("unnamed initializer for %qT, which has no base classes",
1174                  current_class_type);
1175           return NULL_TREE;
1176         case 1:
1177           basetype = BINFO_TYPE
1178             (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1179           break;
1180         default:
1181           error ("unnamed initializer for %qT, which uses multiple inheritance",
1182                  current_class_type);
1183           return NULL_TREE;
1184       }
1185     }
1186   else if (TYPE_P (name))
1187     {
1188       basetype = TYPE_MAIN_VARIANT (name);
1189       name = TYPE_NAME (name);
1190     }
1191   else if (TREE_CODE (name) == TYPE_DECL)
1192     basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1193   else
1194     basetype = NULL_TREE;
1195
1196   if (basetype)
1197     {
1198       tree class_binfo;
1199       tree direct_binfo;
1200       tree virtual_binfo;
1201       int i;
1202
1203       if (current_template_parms)
1204         return basetype;
1205
1206       class_binfo = TYPE_BINFO (current_class_type);
1207       direct_binfo = NULL_TREE;
1208       virtual_binfo = NULL_TREE;
1209
1210       /* Look for a direct base.  */
1211       for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1212         if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1213           break;
1214
1215       /* Look for a virtual base -- unless the direct base is itself
1216          virtual.  */
1217       if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1218         virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1219
1220       /* [class.base.init]
1221
1222          If a mem-initializer-id is ambiguous because it designates
1223          both a direct non-virtual base class and an inherited virtual
1224          base class, the mem-initializer is ill-formed.  */
1225       if (direct_binfo && virtual_binfo)
1226         {
1227           error ("%qD is both a direct base and an indirect virtual base",
1228                  basetype);
1229           return NULL_TREE;
1230         }
1231
1232       if (!direct_binfo && !virtual_binfo)
1233         {
1234           if (CLASSTYPE_VBASECLASSES (current_class_type))
1235             error ("type %qT is not a direct or virtual base of %qT",
1236                    basetype, current_class_type);
1237           else
1238             error ("type %qT is not a direct base of %qT",
1239                    basetype, current_class_type);
1240           return NULL_TREE;
1241         }
1242
1243       return direct_binfo ? direct_binfo : virtual_binfo;
1244     }
1245   else
1246     {
1247       if (TREE_CODE (name) == IDENTIFIER_NODE)
1248         field = lookup_field (current_class_type, name, 1, false);
1249       else
1250         field = name;
1251
1252       if (member_init_ok_or_else (field, current_class_type, name))
1253         return field;
1254     }
1255
1256   return NULL_TREE;
1257 }
1258
1259 /* This is like `expand_member_init', only it stores one aggregate
1260    value into another.
1261
1262    INIT comes in two flavors: it is either a value which
1263    is to be stored in EXP, or it is a parameter list
1264    to go to a constructor, which will operate on EXP.
1265    If INIT is not a parameter list for a constructor, then set
1266    LOOKUP_ONLYCONVERTING.
1267    If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1268    the initializer, if FLAGS is 0, then it is the (init) form.
1269    If `init' is a CONSTRUCTOR, then we emit a warning message,
1270    explaining that such initializations are invalid.
1271
1272    If INIT resolves to a CALL_EXPR which happens to return
1273    something of the type we are looking for, then we know
1274    that we can safely use that call to perform the
1275    initialization.
1276
1277    The virtual function table pointer cannot be set up here, because
1278    we do not really know its type.
1279
1280    This never calls operator=().
1281
1282    When initializing, nothing is CONST.
1283
1284    A default copy constructor may have to be used to perform the
1285    initialization.
1286
1287    A constructor or a conversion operator may have to be used to
1288    perform the initialization, but not both, as it would be ambiguous.  */
1289
1290 tree
1291 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1292 {
1293   tree stmt_expr;
1294   tree compound_stmt;
1295   int destroy_temps;
1296   tree type = TREE_TYPE (exp);
1297   int was_const = TREE_READONLY (exp);
1298   int was_volatile = TREE_THIS_VOLATILE (exp);
1299   int is_global;
1300
1301   if (init == error_mark_node)
1302     return error_mark_node;
1303
1304   TREE_READONLY (exp) = 0;
1305   TREE_THIS_VOLATILE (exp) = 0;
1306
1307   if (init && TREE_CODE (init) != TREE_LIST
1308       && !(BRACE_ENCLOSED_INITIALIZER_P (init)
1309            && CONSTRUCTOR_IS_DIRECT_INIT (init)))
1310     flags |= LOOKUP_ONLYCONVERTING;
1311
1312   if (TREE_CODE (type) == ARRAY_TYPE)
1313     {
1314       tree itype;
1315
1316       /* An array may not be initialized use the parenthesized
1317          initialization form -- unless the initializer is "()".  */
1318       if (init && TREE_CODE (init) == TREE_LIST)
1319         {
1320           if (complain & tf_error)
1321             error ("bad array initializer");
1322           return error_mark_node;
1323         }
1324       /* Must arrange to initialize each element of EXP
1325          from elements of INIT.  */
1326       itype = init ? TREE_TYPE (init) : NULL_TREE;
1327       if (cv_qualified_p (type))
1328         TREE_TYPE (exp) = cv_unqualified (type);
1329       if (itype && cv_qualified_p (itype))
1330         TREE_TYPE (init) = cv_unqualified (itype);
1331       stmt_expr = build_vec_init (exp, NULL_TREE, init,
1332                                   /*explicit_value_init_p=*/false,
1333                                   itype && same_type_p (TREE_TYPE (init),
1334                                                         TREE_TYPE (exp)),
1335                                   complain);
1336       TREE_READONLY (exp) = was_const;
1337       TREE_THIS_VOLATILE (exp) = was_volatile;
1338       TREE_TYPE (exp) = type;
1339       if (init)
1340         TREE_TYPE (init) = itype;
1341       return stmt_expr;
1342     }
1343
1344   if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1345     /* Just know that we've seen something for this node.  */
1346     TREE_USED (exp) = 1;
1347
1348   is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1349   destroy_temps = stmts_are_full_exprs_p ();
1350   current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1351   expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1352                       init, LOOKUP_NORMAL|flags, complain);
1353   stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1354   current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1355   TREE_READONLY (exp) = was_const;
1356   TREE_THIS_VOLATILE (exp) = was_volatile;
1357
1358   return stmt_expr;
1359 }
1360
1361 static void
1362 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1363                      tsubst_flags_t complain)
1364 {
1365   tree type = TREE_TYPE (exp);
1366   tree ctor_name;
1367
1368   /* It fails because there may not be a constructor which takes
1369      its own type as the first (or only parameter), but which does
1370      take other types via a conversion.  So, if the thing initializing
1371      the expression is a unit element of type X, first try X(X&),
1372      followed by initialization by X.  If neither of these work
1373      out, then look hard.  */
1374   tree rval;
1375   VEC(tree,gc) *parms;
1376
1377   if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
1378       && CP_AGGREGATE_TYPE_P (type))
1379     {
1380       /* A brace-enclosed initializer for an aggregate.  In C++0x this can
1381          happen for direct-initialization, too.  */
1382       init = digest_init (type, init);
1383       init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1384       TREE_SIDE_EFFECTS (init) = 1;
1385       finish_expr_stmt (init);
1386       return;
1387     }
1388
1389   if (init && TREE_CODE (init) != TREE_LIST
1390       && (flags & LOOKUP_ONLYCONVERTING))
1391     {
1392       /* Base subobjects should only get direct-initialization.  */
1393       gcc_assert (true_exp == exp);
1394
1395       if (flags & DIRECT_BIND)
1396         /* Do nothing.  We hit this in two cases:  Reference initialization,
1397            where we aren't initializing a real variable, so we don't want
1398            to run a new constructor; and catching an exception, where we
1399            have already built up the constructor call so we could wrap it
1400            in an exception region.  */;
1401       else
1402         init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1403
1404       if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1405         /* We need to protect the initialization of a catch parm with a
1406            call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1407            around the TARGET_EXPR for the copy constructor.  See
1408            initialize_handler_parm.  */
1409         {
1410           TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1411                                            TREE_OPERAND (init, 0));
1412           TREE_TYPE (init) = void_type_node;
1413         }
1414       else
1415         init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1416       TREE_SIDE_EFFECTS (init) = 1;
1417       finish_expr_stmt (init);
1418       return;
1419     }
1420
1421   if (init == NULL_TREE)
1422     parms = NULL;
1423   else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init))
1424     {
1425       parms = make_tree_vector ();
1426       for (; init != NULL_TREE; init = TREE_CHAIN (init))
1427         VEC_safe_push (tree, gc, parms, TREE_VALUE (init));
1428     }
1429   else
1430     parms = make_tree_vector_single (init);
1431
1432   if (true_exp == exp)
1433     ctor_name = complete_ctor_identifier;
1434   else
1435     ctor_name = base_ctor_identifier;
1436
1437   rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
1438                                     complain);
1439
1440   if (parms != NULL)
1441     release_tree_vector (parms);
1442
1443   if (exp == true_exp && TREE_CODE (rval) == CALL_EXPR)
1444     {
1445       tree fn = get_callee_fndecl (rval);
1446       if (fn && DECL_DECLARED_CONSTEXPR_P (fn))
1447         {
1448           tree e = maybe_constant_value (rval);
1449           if (TREE_CONSTANT (e))
1450             rval = build2 (INIT_EXPR, type, exp, e);
1451         }
1452     }
1453
1454   /* FIXME put back convert_to_void?  */
1455   if (TREE_SIDE_EFFECTS (rval))
1456     finish_expr_stmt (rval);
1457 }
1458
1459 /* This function is responsible for initializing EXP with INIT
1460    (if any).
1461
1462    BINFO is the binfo of the type for who we are performing the
1463    initialization.  For example, if W is a virtual base class of A and B,
1464    and C : A, B.
1465    If we are initializing B, then W must contain B's W vtable, whereas
1466    were we initializing C, W must contain C's W vtable.
1467
1468    TRUE_EXP is nonzero if it is the true expression being initialized.
1469    In this case, it may be EXP, or may just contain EXP.  The reason we
1470    need this is because if EXP is a base element of TRUE_EXP, we
1471    don't necessarily know by looking at EXP where its virtual
1472    baseclass fields should really be pointing.  But we do know
1473    from TRUE_EXP.  In constructors, we don't know anything about
1474    the value being initialized.
1475
1476    FLAGS is just passed to `build_new_method_call'.  See that function
1477    for its description.  */
1478
1479 static void
1480 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1481                     tsubst_flags_t complain)
1482 {
1483   tree type = TREE_TYPE (exp);
1484
1485   gcc_assert (init != error_mark_node && type != error_mark_node);
1486   gcc_assert (building_stmt_tree ());
1487
1488   /* Use a function returning the desired type to initialize EXP for us.
1489      If the function is a constructor, and its first argument is
1490      NULL_TREE, know that it was meant for us--just slide exp on
1491      in and expand the constructor.  Constructors now come
1492      as TARGET_EXPRs.  */
1493
1494   if (init && TREE_CODE (exp) == VAR_DECL
1495       && COMPOUND_LITERAL_P (init))
1496     {
1497       /* If store_init_value returns NULL_TREE, the INIT has been
1498          recorded as the DECL_INITIAL for EXP.  That means there's
1499          nothing more we have to do.  */
1500       init = store_init_value (exp, init, flags);
1501       if (init)
1502         finish_expr_stmt (init);
1503       return;
1504     }
1505
1506   /* If an explicit -- but empty -- initializer list was present,
1507      that's value-initialization.  */
1508   if (init == void_type_node)
1509     {
1510       /* If there's a user-provided constructor, we just call that.  */
1511       if (type_has_user_provided_constructor (type))
1512         /* Fall through.  */;
1513       /* If there isn't, but we still need to call the constructor,
1514          zero out the object first.  */
1515       else if (TYPE_NEEDS_CONSTRUCTING (type))
1516         {
1517           init = build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
1518           init = build2 (INIT_EXPR, type, exp, init);
1519           finish_expr_stmt (init);
1520           /* And then call the constructor.  */
1521         }
1522       /* If we don't need to mess with the constructor at all,
1523          then just zero out the object and we're done.  */
1524       else
1525         {
1526           init = build2 (INIT_EXPR, type, exp,
1527                          build_value_init_noctor (type, complain));
1528           finish_expr_stmt (init);
1529           return;
1530         }
1531       init = NULL_TREE;
1532     }
1533
1534   /* We know that expand_default_init can handle everything we want
1535      at this point.  */
1536   expand_default_init (binfo, true_exp, exp, init, flags, complain);
1537 }
1538
1539 /* Report an error if TYPE is not a user-defined, class type.  If
1540    OR_ELSE is nonzero, give an error message.  */
1541
1542 int
1543 is_class_type (tree type, int or_else)
1544 {
1545   if (type == error_mark_node)
1546     return 0;
1547
1548   if (! CLASS_TYPE_P (type))
1549     {
1550       if (or_else)
1551         error ("%qT is not a class type", type);
1552       return 0;
1553     }
1554   return 1;
1555 }
1556
1557 tree
1558 get_type_value (tree name)
1559 {
1560   if (name == error_mark_node)
1561     return NULL_TREE;
1562
1563   if (IDENTIFIER_HAS_TYPE_VALUE (name))
1564     return IDENTIFIER_TYPE_VALUE (name);
1565   else
1566     return NULL_TREE;
1567 }
1568
1569 /* Build a reference to a member of an aggregate.  This is not a C++
1570    `&', but really something which can have its address taken, and
1571    then act as a pointer to member, for example TYPE :: FIELD can have
1572    its address taken by saying & TYPE :: FIELD.  ADDRESS_P is true if
1573    this expression is the operand of "&".
1574
1575    @@ Prints out lousy diagnostics for operator <typename>
1576    @@ fields.
1577
1578    @@ This function should be rewritten and placed in search.c.  */
1579
1580 tree
1581 build_offset_ref (tree type, tree member, bool address_p)
1582 {
1583   tree decl;
1584   tree basebinfo = NULL_TREE;
1585
1586   /* class templates can come in as TEMPLATE_DECLs here.  */
1587   if (TREE_CODE (member) == TEMPLATE_DECL)
1588     return member;
1589
1590   if (dependent_scope_p (type) || type_dependent_expression_p (member))
1591     return build_qualified_name (NULL_TREE, type, member,
1592                                   /*template_p=*/false);
1593
1594   gcc_assert (TYPE_P (type));
1595   if (! is_class_type (type, 1))
1596     return error_mark_node;
1597
1598   gcc_assert (DECL_P (member) || BASELINK_P (member));
1599   /* Callers should call mark_used before this point.  */
1600   gcc_assert (!DECL_P (member) || TREE_USED (member));
1601
1602   type = TYPE_MAIN_VARIANT (type);
1603   if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type)))
1604     {
1605       error ("incomplete type %qT does not have member %qD", type, member);
1606       return error_mark_node;
1607     }
1608
1609   /* Entities other than non-static members need no further
1610      processing.  */
1611   if (TREE_CODE (member) == TYPE_DECL)
1612     return member;
1613   if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1614     return convert_from_reference (member);
1615
1616   if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1617     {
1618       error ("invalid pointer to bit-field %qD", member);
1619       return error_mark_node;
1620     }
1621
1622   /* Set up BASEBINFO for member lookup.  */
1623   decl = maybe_dummy_object (type, &basebinfo);
1624
1625   /* A lot of this logic is now handled in lookup_member.  */
1626   if (BASELINK_P (member))
1627     {
1628       /* Go from the TREE_BASELINK to the member function info.  */
1629       tree t = BASELINK_FUNCTIONS (member);
1630
1631       if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1632         {
1633           /* Get rid of a potential OVERLOAD around it.  */
1634           t = OVL_CURRENT (t);
1635
1636           /* Unique functions are handled easily.  */
1637
1638           /* For non-static member of base class, we need a special rule
1639              for access checking [class.protected]:
1640
1641                If the access is to form a pointer to member, the
1642                nested-name-specifier shall name the derived class
1643                (or any class derived from that class).  */
1644           if (address_p && DECL_P (t)
1645               && DECL_NONSTATIC_MEMBER_P (t))
1646             perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1647           else
1648             perform_or_defer_access_check (basebinfo, t, t);
1649
1650           if (DECL_STATIC_FUNCTION_P (t))
1651             return t;
1652           member = t;
1653         }
1654       else
1655         TREE_TYPE (member) = unknown_type_node;
1656     }
1657   else if (address_p && TREE_CODE (member) == FIELD_DECL)
1658     /* We need additional test besides the one in
1659        check_accessibility_of_qualified_id in case it is
1660        a pointer to non-static member.  */
1661     perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1662
1663   if (!address_p)
1664     {
1665       /* If MEMBER is non-static, then the program has fallen afoul of
1666          [expr.prim]:
1667
1668            An id-expression that denotes a nonstatic data member or
1669            nonstatic member function of a class can only be used:
1670
1671            -- as part of a class member access (_expr.ref_) in which the
1672            object-expression refers to the member's class or a class
1673            derived from that class, or
1674
1675            -- to form a pointer to member (_expr.unary.op_), or
1676
1677            -- in the body of a nonstatic member function of that class or
1678            of a class derived from that class (_class.mfct.nonstatic_), or
1679
1680            -- in a mem-initializer for a constructor for that class or for
1681            a class derived from that class (_class.base.init_).  */
1682       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1683         {
1684           /* Build a representation of the qualified name suitable
1685              for use as the operand to "&" -- even though the "&" is
1686              not actually present.  */
1687           member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1688           /* In Microsoft mode, treat a non-static member function as if
1689              it were a pointer-to-member.  */
1690           if (flag_ms_extensions)
1691             {
1692               PTRMEM_OK_P (member) = 1;
1693               return cp_build_addr_expr (member, tf_warning_or_error);
1694             }
1695           error ("invalid use of non-static member function %qD",
1696                  TREE_OPERAND (member, 1));
1697           return error_mark_node;
1698         }
1699       else if (TREE_CODE (member) == FIELD_DECL)
1700         {
1701           error ("invalid use of non-static data member %qD", member);
1702           return error_mark_node;
1703         }
1704       return member;
1705     }
1706
1707   member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1708   PTRMEM_OK_P (member) = 1;
1709   return member;
1710 }
1711
1712 /* If DECL is a scalar enumeration constant or variable with a
1713    constant initializer, return the initializer (or, its initializers,
1714    recursively); otherwise, return DECL.  If INTEGRAL_P, the
1715    initializer is only returned if DECL is an integral
1716    constant-expression.  */
1717
1718 static tree
1719 constant_value_1 (tree decl, bool integral_p)
1720 {
1721   while (TREE_CODE (decl) == CONST_DECL
1722          || (integral_p
1723              ? decl_constant_var_p (decl)
1724              : (TREE_CODE (decl) == VAR_DECL
1725                 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1726     {
1727       tree init;
1728       /* If DECL is a static data member in a template
1729          specialization, we must instantiate it here.  The
1730          initializer for the static data member is not processed
1731          until needed; we need it now.  */
1732       mark_used (decl);
1733       mark_rvalue_use (decl);
1734       init = DECL_INITIAL (decl);
1735       if (init == error_mark_node)
1736         {
1737           if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
1738             /* Treat the error as a constant to avoid cascading errors on
1739                excessively recursive template instantiation (c++/9335).  */
1740             return init;
1741           else
1742             return decl;
1743         }
1744       /* Initializers in templates are generally expanded during
1745          instantiation, so before that for const int i(2)
1746          INIT is a TREE_LIST with the actual initializer as
1747          TREE_VALUE.  */
1748       if (processing_template_decl
1749           && init
1750           && TREE_CODE (init) == TREE_LIST
1751           && TREE_CHAIN (init) == NULL_TREE)
1752         init = TREE_VALUE (init);
1753       if (!init
1754           || !TREE_TYPE (init)
1755           || uses_template_parms (init)
1756           || (integral_p
1757               ? false
1758               : (!TREE_CONSTANT (init)
1759                  /* Do not return an aggregate constant (of which
1760                     string literals are a special case), as we do not
1761                     want to make inadvertent copies of such entities,
1762                     and we must be sure that their addresses are the
1763                     same everywhere.  */
1764                  || TREE_CODE (init) == CONSTRUCTOR
1765                  || TREE_CODE (init) == STRING_CST)))
1766         break;
1767       decl = unshare_expr (init);
1768     }
1769   return decl;
1770 }
1771
1772 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1773    constant of integral or enumeration type, then return that value.
1774    These are those variables permitted in constant expressions by
1775    [5.19/1].  */
1776
1777 tree
1778 integral_constant_value (tree decl)
1779 {
1780   return constant_value_1 (decl, /*integral_p=*/true);
1781 }
1782
1783 /* A more relaxed version of integral_constant_value, used by the
1784    common C/C++ code and by the C++ front end for optimization
1785    purposes.  */
1786
1787 tree
1788 decl_constant_value (tree decl)
1789 {
1790   return constant_value_1 (decl,
1791                            /*integral_p=*/processing_template_decl);
1792 }
1793 \f
1794 /* Common subroutines of build_new and build_vec_delete.  */
1795
1796 /* Call the global __builtin_delete to delete ADDR.  */
1797
1798 static tree
1799 build_builtin_delete_call (tree addr)
1800 {
1801   mark_used (global_delete_fndecl);
1802   return build_call_n (global_delete_fndecl, 1, addr);
1803 }
1804 \f
1805 /* Build and return a NEW_EXPR.  If NELTS is non-NULL, TYPE[NELTS] is
1806    the type of the object being allocated; otherwise, it's just TYPE.
1807    INIT is the initializer, if any.  USE_GLOBAL_NEW is true if the
1808    user explicitly wrote "::operator new".  PLACEMENT, if non-NULL, is
1809    a vector of arguments to be provided as arguments to a placement
1810    new operator.  This routine performs no semantic checks; it just
1811    creates and returns a NEW_EXPR.  */
1812
1813 static tree
1814 build_raw_new_expr (VEC(tree,gc) *placement, tree type, tree nelts,
1815                     VEC(tree,gc) *init, int use_global_new)
1816 {
1817   tree init_list;
1818   tree new_expr;
1819
1820   /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
1821      If INIT is not NULL, then we want to store VOID_ZERO_NODE.  This
1822      permits us to distinguish the case of a missing initializer "new
1823      int" from an empty initializer "new int()".  */
1824   if (init == NULL)
1825     init_list = NULL_TREE;
1826   else if (VEC_empty (tree, init))
1827     init_list = void_zero_node;
1828   else
1829     init_list = build_tree_list_vec (init);
1830
1831   new_expr = build4 (NEW_EXPR, build_pointer_type (type),
1832                      build_tree_list_vec (placement), type, nelts,
1833                      init_list);
1834   NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1835   TREE_SIDE_EFFECTS (new_expr) = 1;
1836
1837   return new_expr;
1838 }
1839
1840 /* Diagnose uninitialized const members or reference members of type
1841    TYPE. USING_NEW is used to disambiguate the diagnostic between a
1842    new expression without a new-initializer and a declaration. Returns
1843    the error count. */
1844
1845 static int
1846 diagnose_uninitialized_cst_or_ref_member_1 (tree type, tree origin,
1847                                             bool using_new, bool complain)
1848 {
1849   tree field;
1850   int error_count = 0;
1851
1852   if (type_has_user_provided_constructor (type))
1853     return 0;
1854
1855   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1856     {
1857       tree field_type;
1858
1859       if (TREE_CODE (field) != FIELD_DECL)
1860         continue;
1861
1862       field_type = strip_array_types (TREE_TYPE (field));
1863
1864       if (TREE_CODE (field_type) == REFERENCE_TYPE)
1865         {
1866           ++ error_count;
1867           if (complain)
1868             {
1869               if (using_new)
1870                 error ("uninitialized reference member in %q#T "
1871                        "using %<new%> without new-initializer", origin);
1872               else
1873                 error ("uninitialized reference member in %q#T", origin);
1874               inform (DECL_SOURCE_LOCATION (field),
1875                       "%qD should be initialized", field);
1876             }
1877         }
1878
1879       if (CP_TYPE_CONST_P (field_type))
1880         {
1881           ++ error_count;
1882           if (complain)
1883             {
1884               if (using_new)
1885                 error ("uninitialized const member in %q#T "
1886                        "using %<new%> without new-initializer", origin);
1887               else
1888                 error ("uninitialized const member in %q#T", origin);
1889               inform (DECL_SOURCE_LOCATION (field),
1890                       "%qD should be initialized", field);
1891             }
1892         }
1893
1894       if (CLASS_TYPE_P (field_type))
1895         error_count
1896           += diagnose_uninitialized_cst_or_ref_member_1 (field_type, origin,
1897                                                          using_new, complain);
1898     }
1899   return error_count;
1900 }
1901
1902 int
1903 diagnose_uninitialized_cst_or_ref_member (tree type, bool using_new, bool complain)
1904 {
1905   return diagnose_uninitialized_cst_or_ref_member_1 (type, type, using_new, complain);
1906 }
1907
1908 /* Generate code for a new-expression, including calling the "operator
1909    new" function, initializing the object, and, if an exception occurs
1910    during construction, cleaning up.  The arguments are as for
1911    build_raw_new_expr.  This may change PLACEMENT and INIT.  */
1912
1913 static tree
1914 build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
1915              VEC(tree,gc) **init, bool globally_qualified_p,
1916              tsubst_flags_t complain)
1917 {
1918   tree size, rval;
1919   /* True iff this is a call to "operator new[]" instead of just
1920      "operator new".  */
1921   bool array_p = false;
1922   /* If ARRAY_P is true, the element type of the array.  This is never
1923      an ARRAY_TYPE; for something like "new int[3][4]", the
1924      ELT_TYPE is "int".  If ARRAY_P is false, this is the same type as
1925      TYPE.  */
1926   tree elt_type;
1927   /* The type of the new-expression.  (This type is always a pointer
1928      type.)  */
1929   tree pointer_type;
1930   tree non_const_pointer_type;
1931   tree outer_nelts = NULL_TREE;
1932   tree alloc_call, alloc_expr;
1933   /* The address returned by the call to "operator new".  This node is
1934      a VAR_DECL and is therefore reusable.  */
1935   tree alloc_node;
1936   tree alloc_fn;
1937   tree cookie_expr, init_expr;
1938   int nothrow, check_new;
1939   int use_java_new = 0;
1940   /* If non-NULL, the number of extra bytes to allocate at the
1941      beginning of the storage allocated for an array-new expression in
1942      order to store the number of elements.  */
1943   tree cookie_size = NULL_TREE;
1944   tree placement_first;
1945   tree placement_expr = NULL_TREE;
1946   /* True if the function we are calling is a placement allocation
1947      function.  */
1948   bool placement_allocation_fn_p;
1949   /* True if the storage must be initialized, either by a constructor
1950      or due to an explicit new-initializer.  */
1951   bool is_initialized;
1952   /* The address of the thing allocated, not including any cookie.  In
1953      particular, if an array cookie is in use, DATA_ADDR is the
1954      address of the first array element.  This node is a VAR_DECL, and
1955      is therefore reusable.  */
1956   tree data_addr;
1957   tree init_preeval_expr = NULL_TREE;
1958
1959   if (nelts)
1960     {
1961       outer_nelts = nelts;
1962       array_p = true;
1963     }
1964   else if (TREE_CODE (type) == ARRAY_TYPE)
1965     {
1966       array_p = true;
1967       nelts = array_type_nelts_top (type);
1968       outer_nelts = nelts;
1969       type = TREE_TYPE (type);
1970     }
1971
1972   /* If our base type is an array, then make sure we know how many elements
1973      it has.  */
1974   for (elt_type = type;
1975        TREE_CODE (elt_type) == ARRAY_TYPE;
1976        elt_type = TREE_TYPE (elt_type))
1977     nelts = cp_build_binary_op (input_location,
1978                                 MULT_EXPR, nelts,
1979                                 array_type_nelts_top (elt_type),
1980                                 complain);
1981
1982   if (TREE_CODE (elt_type) == VOID_TYPE)
1983     {
1984       if (complain & tf_error)
1985         error ("invalid type %<void%> for new");
1986       return error_mark_node;
1987     }
1988
1989   if (abstract_virtuals_error (NULL_TREE, elt_type))
1990     return error_mark_node;
1991
1992   is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || *init != NULL);
1993
1994   if (*init == NULL)
1995     {
1996       bool maybe_uninitialized_error = false;
1997       /* A program that calls for default-initialization [...] of an
1998          entity of reference type is ill-formed. */
1999       if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type))
2000         maybe_uninitialized_error = true;
2001
2002       /* A new-expression that creates an object of type T initializes
2003          that object as follows:
2004       - If the new-initializer is omitted:
2005         -- If T is a (possibly cv-qualified) non-POD class type
2006            (or array thereof), the object is default-initialized (8.5).
2007            [...]
2008         -- Otherwise, the object created has indeterminate
2009            value. If T is a const-qualified type, or a (possibly
2010            cv-qualified) POD class type (or array thereof)
2011            containing (directly or indirectly) a member of
2012            const-qualified type, the program is ill-formed; */
2013
2014       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type))
2015         maybe_uninitialized_error = true;
2016
2017       if (maybe_uninitialized_error
2018           && diagnose_uninitialized_cst_or_ref_member (elt_type,
2019                                                        /*using_new=*/true,
2020                                                        complain & tf_error))
2021         return error_mark_node;
2022     }
2023
2024   if (CP_TYPE_CONST_P (elt_type) && *init == NULL
2025       && !type_has_user_provided_default_constructor (elt_type))
2026     {
2027       if (complain & tf_error)
2028         error ("uninitialized const in %<new%> of %q#T", elt_type);
2029       return error_mark_node;
2030     }
2031
2032   size = size_in_bytes (elt_type);
2033   if (array_p)
2034     size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
2035
2036   alloc_fn = NULL_TREE;
2037
2038   /* If PLACEMENT is a single simple pointer type not passed by
2039      reference, prepare to capture it in a temporary variable.  Do
2040      this now, since PLACEMENT will change in the calls below.  */
2041   placement_first = NULL_TREE;
2042   if (VEC_length (tree, *placement) == 1
2043       && (TREE_CODE (TREE_TYPE (VEC_index (tree, *placement, 0)))
2044           == POINTER_TYPE))
2045     placement_first = VEC_index (tree, *placement, 0);
2046
2047   /* Allocate the object.  */
2048   if (VEC_empty (tree, *placement) && TYPE_FOR_JAVA (elt_type))
2049     {
2050       tree class_addr;
2051       tree class_decl = build_java_class_ref (elt_type);
2052       static const char alloc_name[] = "_Jv_AllocObject";
2053
2054       if (class_decl == error_mark_node)
2055         return error_mark_node;
2056
2057       use_java_new = 1;
2058       if (!get_global_value_if_present (get_identifier (alloc_name),
2059                                         &alloc_fn))
2060         {
2061           if (complain & tf_error)
2062             error ("call to Java constructor with %qs undefined", alloc_name);
2063           return error_mark_node;
2064         }
2065       else if (really_overloaded_fn (alloc_fn))
2066         {
2067           if (complain & tf_error)
2068             error ("%qD should never be overloaded", alloc_fn);
2069           return error_mark_node;
2070         }
2071       alloc_fn = OVL_CURRENT (alloc_fn);
2072       class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2073       alloc_call = cp_build_function_call_nary (alloc_fn, complain,
2074                                                 class_addr, NULL_TREE);
2075     }
2076   else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
2077     {
2078       error ("Java class %q#T object allocated using placement new", elt_type);
2079       return error_mark_node;
2080     }
2081   else
2082     {
2083       tree fnname;
2084       tree fns;
2085
2086       fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
2087
2088       if (!globally_qualified_p
2089           && CLASS_TYPE_P (elt_type)
2090           && (array_p
2091               ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
2092               : TYPE_HAS_NEW_OPERATOR (elt_type)))
2093         {
2094           /* Use a class-specific operator new.  */
2095           /* If a cookie is required, add some extra space.  */
2096           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2097             {
2098               cookie_size = targetm.cxx.get_cookie_size (elt_type);
2099               size = size_binop (PLUS_EXPR, size, cookie_size);
2100             }
2101           /* Create the argument list.  */
2102           VEC_safe_insert (tree, gc, *placement, 0, size);
2103           /* Do name-lookup to find the appropriate operator.  */
2104           fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
2105           if (fns == NULL_TREE)
2106             {
2107               if (complain & tf_error)
2108                 error ("no suitable %qD found in class %qT", fnname, elt_type);
2109               return error_mark_node;
2110             }
2111           if (TREE_CODE (fns) == TREE_LIST)
2112             {
2113               if (complain & tf_error)
2114                 {
2115                   error ("request for member %qD is ambiguous", fnname);
2116                   print_candidates (fns);
2117                 }
2118               return error_mark_node;
2119             }
2120           alloc_call = build_new_method_call (build_dummy_object (elt_type),
2121                                               fns, placement,
2122                                               /*conversion_path=*/NULL_TREE,
2123                                               LOOKUP_NORMAL,
2124                                               &alloc_fn,
2125                                               complain);
2126         }
2127       else
2128         {
2129           /* Use a global operator new.  */
2130           /* See if a cookie might be required.  */
2131           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2132             cookie_size = targetm.cxx.get_cookie_size (elt_type);
2133           else
2134             cookie_size = NULL_TREE;
2135
2136           alloc_call = build_operator_new_call (fnname, placement,
2137                                                 &size, &cookie_size,
2138                                                 &alloc_fn);
2139         }
2140     }
2141
2142   if (alloc_call == error_mark_node)
2143     return error_mark_node;
2144
2145   gcc_assert (alloc_fn != NULL_TREE);
2146
2147   /* If we found a simple case of PLACEMENT_EXPR above, then copy it
2148      into a temporary variable.  */
2149   if (!processing_template_decl
2150       && placement_first != NULL_TREE
2151       && TREE_CODE (alloc_call) == CALL_EXPR
2152       && call_expr_nargs (alloc_call) == 2
2153       && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
2154       && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
2155     {
2156       tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
2157
2158       if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
2159           || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
2160         {
2161           placement_expr = get_target_expr (placement_first);
2162           CALL_EXPR_ARG (alloc_call, 1)
2163             = convert (TREE_TYPE (placement_arg), placement_expr);
2164         }
2165     }
2166
2167   /* In the simple case, we can stop now.  */
2168   pointer_type = build_pointer_type (type);
2169   if (!cookie_size && !is_initialized)
2170     return build_nop (pointer_type, alloc_call);
2171
2172   /* Store the result of the allocation call in a variable so that we can
2173      use it more than once.  */
2174   alloc_expr = get_target_expr (alloc_call);
2175   alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2176
2177   /* Strip any COMPOUND_EXPRs from ALLOC_CALL.  */
2178   while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2179     alloc_call = TREE_OPERAND (alloc_call, 1);
2180
2181   /* Now, check to see if this function is actually a placement
2182      allocation function.  This can happen even when PLACEMENT is NULL
2183      because we might have something like:
2184
2185        struct S { void* operator new (size_t, int i = 0); };
2186
2187      A call to `new S' will get this allocation function, even though
2188      there is no explicit placement argument.  If there is more than
2189      one argument, or there are variable arguments, then this is a
2190      placement allocation function.  */
2191   placement_allocation_fn_p
2192     = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2193        || varargs_function_p (alloc_fn));
2194
2195   /* Preevaluate the placement args so that we don't reevaluate them for a
2196      placement delete.  */
2197   if (placement_allocation_fn_p)
2198     {
2199       tree inits;
2200       stabilize_call (alloc_call, &inits);
2201       if (inits)
2202         alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2203                              alloc_expr);
2204     }
2205
2206   /*        unless an allocation function is declared with an empty  excep-
2207      tion-specification  (_except.spec_),  throw(), it indicates failure to
2208      allocate storage by throwing a bad_alloc exception  (clause  _except_,
2209      _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2210      cation function is declared  with  an  empty  exception-specification,
2211      throw(), it returns null to indicate failure to allocate storage and a
2212      non-null pointer otherwise.
2213
2214      So check for a null exception spec on the op new we just called.  */
2215
2216   nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2217   check_new = (flag_check_new || nothrow) && ! use_java_new;
2218
2219   if (cookie_size)
2220     {
2221       tree cookie;
2222       tree cookie_ptr;
2223       tree size_ptr_type;
2224
2225       /* Adjust so we're pointing to the start of the object.  */
2226       data_addr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2227                           alloc_node, cookie_size);
2228
2229       /* Store the number of bytes allocated so that we can know how
2230          many elements to destroy later.  We use the last sizeof
2231          (size_t) bytes to store the number of elements.  */
2232       cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2233       cookie_ptr = fold_build2_loc (input_location,
2234                                 POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2235                                 alloc_node, cookie_ptr);
2236       size_ptr_type = build_pointer_type (sizetype);
2237       cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2238       cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2239
2240       cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2241
2242       if (targetm.cxx.cookie_has_size ())
2243         {
2244           /* Also store the element size.  */
2245           cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, cookie_ptr,
2246                                fold_build1_loc (input_location,
2247                                             NEGATE_EXPR, sizetype,
2248                                             size_in_bytes (sizetype)));
2249
2250           cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2251           cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2252                            size_in_bytes (elt_type));
2253           cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2254                                 cookie, cookie_expr);
2255         }
2256     }
2257   else
2258     {
2259       cookie_expr = NULL_TREE;
2260       data_addr = alloc_node;
2261     }
2262
2263   /* Now use a pointer to the type we've actually allocated.  */
2264
2265   /* But we want to operate on a non-const version to start with,
2266      since we'll be modifying the elements.  */
2267   non_const_pointer_type = build_pointer_type
2268     (cp_build_qualified_type (type, cp_type_quals (type) & ~TYPE_QUAL_CONST));
2269
2270   data_addr = fold_convert (non_const_pointer_type, data_addr);
2271   /* Any further uses of alloc_node will want this type, too.  */
2272   alloc_node = fold_convert (non_const_pointer_type, alloc_node);
2273
2274   /* Now initialize the allocated object.  Note that we preevaluate the
2275      initialization expression, apart from the actual constructor call or
2276      assignment--we do this because we want to delay the allocation as long
2277      as possible in order to minimize the size of the exception region for
2278      placement delete.  */
2279   if (is_initialized)
2280     {
2281       bool stable;
2282       bool explicit_value_init_p = false;
2283
2284       if (*init != NULL && VEC_empty (tree, *init))
2285         {
2286           *init = NULL;
2287           explicit_value_init_p = true;
2288         }
2289
2290       if (array_p)
2291         {
2292           tree vecinit = NULL_TREE;
2293           if (*init && VEC_length (tree, *init) == 1
2294               && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *init, 0))
2295               && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *init, 0)))
2296             {
2297               tree arraytype, domain;
2298               vecinit = VEC_index (tree, *init, 0);
2299               if (TREE_CONSTANT (nelts))
2300                 domain = compute_array_index_type (NULL_TREE, nelts, complain);
2301               else
2302                 {
2303                   domain = NULL_TREE;
2304                   if (CONSTRUCTOR_NELTS (vecinit) > 0)
2305                     warning (0, "non-constant array size in new, unable to "
2306                              "verify length of initializer-list");
2307                 }
2308               arraytype = build_cplus_array_type (type, domain);
2309               vecinit = digest_init (arraytype, vecinit);
2310             }
2311           else if (*init)
2312             {
2313               if (complain & tf_error)
2314                 permerror (input_location, "ISO C++ forbids initialization in array new");
2315               else
2316                 return error_mark_node;
2317               vecinit = build_tree_list_vec (*init);
2318             }
2319           init_expr
2320             = build_vec_init (data_addr,
2321                               cp_build_binary_op (input_location,
2322                                                   MINUS_EXPR, outer_nelts,
2323                                                   integer_one_node,
2324                                                   complain),
2325                               vecinit,
2326                               explicit_value_init_p,
2327                               /*from_array=*/0,
2328                               complain);
2329
2330           /* An array initialization is stable because the initialization
2331              of each element is a full-expression, so the temporaries don't
2332              leak out.  */
2333           stable = true;
2334         }
2335       else
2336         {
2337           init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2338
2339           if (TYPE_NEEDS_CONSTRUCTING (type)
2340               && (!explicit_value_init_p || processing_template_decl))
2341             {
2342               init_expr = build_special_member_call (init_expr,
2343                                                      complete_ctor_identifier,
2344                                                      init, elt_type,
2345                                                      LOOKUP_NORMAL,
2346                                                      complain);
2347             }
2348           else if (explicit_value_init_p)
2349             {
2350               if (processing_template_decl)
2351                 /* Don't worry about it, we'll handle this properly at
2352                    instantiation time.  */;
2353               else
2354                 {
2355                   /* Something like `new int()'.  */
2356                   tree val = build_value_init (type, complain);
2357                   if (val == error_mark_node)
2358                     return error_mark_node;
2359                   init_expr = build2 (INIT_EXPR, type, init_expr, val);
2360                 }
2361             }
2362           else
2363             {
2364               tree ie;
2365
2366               /* We are processing something like `new int (10)', which
2367                  means allocate an int, and initialize it with 10.  */
2368
2369               ie = build_x_compound_expr_from_vec (*init, "new initializer");
2370               init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, ie,
2371                                                 complain);
2372             }
2373           stable = stabilize_init (init_expr, &init_preeval_expr);
2374         }
2375
2376       if (init_expr == error_mark_node)
2377         return error_mark_node;
2378
2379       /* If any part of the object initialization terminates by throwing an
2380          exception and a suitable deallocation function can be found, the
2381          deallocation function is called to free the memory in which the
2382          object was being constructed, after which the exception continues
2383          to propagate in the context of the new-expression. If no
2384          unambiguous matching deallocation function can be found,
2385          propagating the exception does not cause the object's memory to be
2386          freed.  */
2387       if (flag_exceptions && ! use_java_new)
2388         {
2389           enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2390           tree cleanup;
2391
2392           /* The Standard is unclear here, but the right thing to do
2393              is to use the same method for finding deallocation
2394              functions that we use for finding allocation functions.  */
2395           cleanup = (build_op_delete_call
2396                      (dcode,
2397                       alloc_node,
2398                       size,
2399                       globally_qualified_p,
2400                       placement_allocation_fn_p ? alloc_call : NULL_TREE,
2401                       alloc_fn));
2402
2403           if (!cleanup)
2404             /* We're done.  */;
2405           else if (stable)
2406             /* This is much simpler if we were able to preevaluate all of
2407                the arguments to the constructor call.  */
2408             {
2409               /* CLEANUP is compiler-generated, so no diagnostics.  */
2410               TREE_NO_WARNING (cleanup) = true;
2411               init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2412                                   init_expr, cleanup);
2413               /* Likewise, this try-catch is compiler-generated.  */
2414               TREE_NO_WARNING (init_expr) = true;
2415             }
2416           else
2417             /* Ack!  First we allocate the memory.  Then we set our sentry
2418                variable to true, and expand a cleanup that deletes the
2419                memory if sentry is true.  Then we run the constructor, and
2420                finally clear the sentry.
2421
2422                We need to do this because we allocate the space first, so
2423                if there are any temporaries with cleanups in the
2424                constructor args and we weren't able to preevaluate them, we
2425                need this EH region to extend until end of full-expression
2426                to preserve nesting.  */
2427             {
2428               tree end, sentry, begin;
2429
2430               begin = get_target_expr (boolean_true_node);
2431               CLEANUP_EH_ONLY (begin) = 1;
2432
2433               sentry = TARGET_EXPR_SLOT (begin);
2434
2435               /* CLEANUP is compiler-generated, so no diagnostics.  */
2436               TREE_NO_WARNING (cleanup) = true;
2437
2438               TARGET_EXPR_CLEANUP (begin)
2439                 = build3 (COND_EXPR, void_type_node, sentry,
2440                           cleanup, void_zero_node);
2441
2442               end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2443                             sentry, boolean_false_node);
2444
2445               init_expr
2446                 = build2 (COMPOUND_EXPR, void_type_node, begin,
2447                           build2 (COMPOUND_EXPR, void_type_node, init_expr,
2448                                   end));
2449               /* Likewise, this is compiler-generated.  */
2450               TREE_NO_WARNING (init_expr) = true;
2451             }
2452         }
2453     }
2454   else
2455     init_expr = NULL_TREE;
2456
2457   /* Now build up the return value in reverse order.  */
2458
2459   rval = data_addr;
2460
2461   if (init_expr)
2462     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2463   if (cookie_expr)
2464     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2465
2466   if (rval == data_addr)
2467     /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2468        and return the call (which doesn't need to be adjusted).  */
2469     rval = TARGET_EXPR_INITIAL (alloc_expr);
2470   else
2471     {
2472       if (check_new)
2473         {
2474           tree ifexp = cp_build_binary_op (input_location,
2475                                            NE_EXPR, alloc_node,
2476                                            integer_zero_node,
2477                                            complain);
2478           rval = build_conditional_expr (ifexp, rval, alloc_node,
2479                                          complain);
2480         }
2481
2482       /* Perform the allocation before anything else, so that ALLOC_NODE
2483          has been initialized before we start using it.  */
2484       rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2485     }
2486
2487   if (init_preeval_expr)
2488     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2489
2490   /* A new-expression is never an lvalue.  */
2491   gcc_assert (!lvalue_p (rval));
2492
2493   return convert (pointer_type, rval);
2494 }
2495
2496 /* Generate a representation for a C++ "new" expression.  *PLACEMENT
2497    is a vector of placement-new arguments (or NULL if none).  If NELTS
2498    is NULL, TYPE is the type of the storage to be allocated.  If NELTS
2499    is not NULL, then this is an array-new allocation; TYPE is the type
2500    of the elements in the array and NELTS is the number of elements in
2501    the array.  *INIT, if non-NULL, is the initializer for the new
2502    object, or an empty vector to indicate an initializer of "()".  If
2503    USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
2504    rather than just "new".  This may change PLACEMENT and INIT.  */
2505
2506 tree
2507 build_new (VEC(tree,gc) **placement, tree type, tree nelts,
2508            VEC(tree,gc) **init, int use_global_new, tsubst_flags_t complain)
2509 {
2510   tree rval;
2511   VEC(tree,gc) *orig_placement = NULL;
2512   tree orig_nelts = NULL_TREE;
2513   VEC(tree,gc) *orig_init = NULL;
2514
2515   if (type == error_mark_node)
2516     return error_mark_node;
2517
2518   if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2519     {
2520       tree auto_node = type_uses_auto (type);
2521       if (auto_node && describable_type (VEC_index (tree, *init, 0)))
2522         type = do_auto_deduction (type, VEC_index (tree, *init, 0), auto_node);
2523     }
2524
2525   if (processing_template_decl)
2526     {
2527       if (dependent_type_p (type)
2528           || any_type_dependent_arguments_p (*placement)
2529           || (nelts && type_dependent_expression_p (nelts))
2530           || any_type_dependent_arguments_p (*init))
2531         return build_raw_new_expr (*placement, type, nelts, *init,
2532                                    use_global_new);
2533
2534       orig_placement = make_tree_vector_copy (*placement);
2535       orig_nelts = nelts;
2536       orig_init = make_tree_vector_copy (*init);
2537
2538       make_args_non_dependent (*placement);
2539       if (nelts)
2540         nelts = build_non_dependent_expr (nelts);
2541       make_args_non_dependent (*init);
2542     }
2543
2544   if (nelts)
2545     {
2546       if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2547         {
2548           if (complain & tf_error)
2549             permerror (input_location, "size in array new must have integral type");
2550           else
2551             return error_mark_node;
2552         }
2553       nelts = mark_rvalue_use (nelts);
2554       nelts = cp_save_expr (cp_convert (sizetype, nelts));
2555     }
2556
2557   /* ``A reference cannot be created by the new operator.  A reference
2558      is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2559      returned by new.'' ARM 5.3.3 */
2560   if (TREE_CODE (type) == REFERENCE_TYPE)
2561     {
2562       if (complain & tf_error)
2563         error ("new cannot be applied to a reference type");
2564       else
2565         return error_mark_node;
2566       type = TREE_TYPE (type);
2567     }
2568
2569   if (TREE_CODE (type) == FUNCTION_TYPE)
2570     {
2571       if (complain & tf_error)
2572         error ("new cannot be applied to a function type");
2573       return error_mark_node;
2574     }
2575
2576   /* The type allocated must be complete.  If the new-type-id was
2577      "T[N]" then we are just checking that "T" is complete here, but
2578      that is equivalent, since the value of "N" doesn't matter.  */
2579   if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
2580     return error_mark_node;
2581
2582   rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2583   if (rval == error_mark_node)
2584     return error_mark_node;
2585
2586   if (processing_template_decl)
2587     {
2588       tree ret = build_raw_new_expr (orig_placement, type, orig_nelts,
2589                                      orig_init, use_global_new);
2590       release_tree_vector (orig_placement);
2591       release_tree_vector (orig_init);
2592       return ret;
2593     }
2594
2595   /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain.  */
2596   rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2597   TREE_NO_WARNING (rval) = 1;
2598
2599   return rval;
2600 }
2601
2602 /* Given a Java class, return a decl for the corresponding java.lang.Class.  */
2603
2604 tree
2605 build_java_class_ref (tree type)
2606 {
2607   tree name = NULL_TREE, class_decl;
2608   static tree CL_suffix = NULL_TREE;
2609   if (CL_suffix == NULL_TREE)
2610     CL_suffix = get_identifier("class$");
2611   if (jclass_node == NULL_TREE)
2612     {
2613       jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2614       if (jclass_node == NULL_TREE)
2615         {
2616           error ("call to Java constructor, while %<jclass%> undefined");
2617           return error_mark_node;
2618         }
2619       jclass_node = TREE_TYPE (jclass_node);
2620     }
2621
2622   /* Mangle the class$ field.  */
2623   {
2624     tree field;
2625     for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2626       if (DECL_NAME (field) == CL_suffix)
2627         {
2628           mangle_decl (field);
2629           name = DECL_ASSEMBLER_NAME (field);
2630           break;
2631         }
2632     if (!field)
2633       {
2634         error ("can't find %<class$%> in %qT", type);
2635         return error_mark_node;
2636       }
2637   }
2638
2639   class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2640   if (class_decl == NULL_TREE)
2641     {
2642       class_decl = build_decl (input_location,
2643                                VAR_DECL, name, TREE_TYPE (jclass_node));
2644       TREE_STATIC (class_decl) = 1;
2645       DECL_EXTERNAL (class_decl) = 1;
2646       TREE_PUBLIC (class_decl) = 1;
2647       DECL_ARTIFICIAL (class_decl) = 1;
2648       DECL_IGNORED_P (class_decl) = 1;
2649       pushdecl_top_level (class_decl);
2650       make_decl_rtl (class_decl);
2651     }
2652   return class_decl;
2653 }
2654 \f
2655 static tree
2656 build_vec_delete_1 (tree base, tree maxindex, tree type,
2657     special_function_kind auto_delete_vec, int use_global_delete)
2658 {
2659   tree virtual_size;
2660   tree ptype = build_pointer_type (type = complete_type (type));
2661   tree size_exp = size_in_bytes (type);
2662
2663   /* Temporary variables used by the loop.  */
2664   tree tbase, tbase_init;
2665
2666   /* This is the body of the loop that implements the deletion of a
2667      single element, and moves temp variables to next elements.  */
2668   tree body;
2669
2670   /* This is the LOOP_EXPR that governs the deletion of the elements.  */
2671   tree loop = 0;
2672
2673   /* This is the thing that governs what to do after the loop has run.  */
2674   tree deallocate_expr = 0;
2675
2676   /* This is the BIND_EXPR which holds the outermost iterator of the
2677      loop.  It is convenient to set this variable up and test it before
2678      executing any other code in the loop.
2679      This is also the containing expression returned by this function.  */
2680   tree controller = NULL_TREE;
2681   tree tmp;
2682
2683   /* We should only have 1-D arrays here.  */
2684   gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2685
2686   if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2687     goto no_destructor;
2688
2689   /* The below is short by the cookie size.  */
2690   virtual_size = size_binop (MULT_EXPR, size_exp,
2691                              convert (sizetype, maxindex));
2692
2693   tbase = create_temporary_var (ptype);
2694   tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
2695                                      fold_build2_loc (input_location,
2696                                                   POINTER_PLUS_EXPR, ptype,
2697                                                   fold_convert (ptype, base),
2698                                                   virtual_size),
2699                                      tf_warning_or_error);
2700   controller = build3 (BIND_EXPR, void_type_node, tbase,
2701                        NULL_TREE, NULL_TREE);
2702   TREE_SIDE_EFFECTS (controller) = 1;
2703
2704   body = build1 (EXIT_EXPR, void_type_node,
2705                  build2 (EQ_EXPR, boolean_type_node, tbase,
2706                          fold_convert (ptype, base)));
2707   tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp);
2708   body = build_compound_expr
2709     (input_location,
2710      body, cp_build_modify_expr (tbase, NOP_EXPR,
2711                                  build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp),
2712                                  tf_warning_or_error));
2713   body = build_compound_expr
2714     (input_location,
2715      body, build_delete (ptype, tbase, sfk_complete_destructor,
2716                          LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2717
2718   loop = build1 (LOOP_EXPR, void_type_node, body);
2719   loop = build_compound_expr (input_location, tbase_init, loop);
2720
2721  no_destructor:
2722   /* If the delete flag is one, or anything else with the low bit set,
2723      delete the storage.  */
2724   if (auto_delete_vec != sfk_base_destructor)
2725     {
2726       tree base_tbd;
2727
2728       /* The below is short by the cookie size.  */
2729       virtual_size = size_binop (MULT_EXPR, size_exp,
2730                                  convert (sizetype, maxindex));
2731
2732       if (! TYPE_VEC_NEW_USES_COOKIE (type))
2733         /* no header */
2734         base_tbd = base;
2735       else
2736         {
2737           tree cookie_size;
2738
2739           cookie_size = targetm.cxx.get_cookie_size (type);
2740           base_tbd
2741             = cp_convert (ptype,
2742                           cp_build_binary_op (input_location,
2743                                               MINUS_EXPR,
2744                                               cp_convert (string_type_node,
2745                                                           base),
2746                                               cookie_size,
2747                                               tf_warning_or_error));
2748           /* True size with header.  */
2749           virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2750         }
2751
2752       if (auto_delete_vec == sfk_deleting_destructor)
2753         deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2754                                                 base_tbd, virtual_size,
2755                                                 use_global_delete & 1,
2756                                                 /*placement=*/NULL_TREE,
2757                                                 /*alloc_fn=*/NULL_TREE);
2758     }
2759
2760   body = loop;
2761   if (!deallocate_expr)
2762     ;
2763   else if (!body)
2764     body = deallocate_expr;
2765   else
2766     body = build_compound_expr (input_location, body, deallocate_expr);
2767
2768   if (!body)
2769     body = integer_zero_node;
2770
2771   /* Outermost wrapper: If pointer is null, punt.  */
2772   body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
2773                       fold_build2_loc (input_location,
2774                                    NE_EXPR, boolean_type_node, base,
2775                                    convert (TREE_TYPE (base),
2776                                             integer_zero_node)),
2777                       body, integer_zero_node);
2778   body = build1 (NOP_EXPR, void_type_node, body);
2779
2780   if (controller)
2781     {
2782       TREE_OPERAND (controller, 1) = body;
2783       body = controller;
2784     }
2785
2786   if (TREE_CODE (base) == SAVE_EXPR)
2787     /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
2788     body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2789
2790   return convert_to_void (body, ICV_CAST, tf_warning_or_error);
2791 }
2792
2793 /* Create an unnamed variable of the indicated TYPE.  */
2794
2795 tree
2796 create_temporary_var (tree type)
2797 {
2798   tree decl;
2799
2800   decl = build_decl (input_location,
2801                      VAR_DECL, NULL_TREE, type);
2802   TREE_USED (decl) = 1;
2803   DECL_ARTIFICIAL (decl) = 1;
2804   DECL_IGNORED_P (decl) = 1;
2805   DECL_CONTEXT (decl) = current_function_decl;
2806
2807   return decl;
2808 }
2809
2810 /* Create a new temporary variable of the indicated TYPE, initialized
2811    to INIT.
2812
2813    It is not entered into current_binding_level, because that breaks
2814    things when it comes time to do final cleanups (which take place
2815    "outside" the binding contour of the function).  */
2816
2817 static tree
2818 get_temp_regvar (tree type, tree init)
2819 {
2820   tree decl;
2821
2822   decl = create_temporary_var (type);
2823   add_decl_expr (decl);
2824
2825   finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
2826                                           tf_warning_or_error));
2827
2828   return decl;
2829 }
2830
2831 /* `build_vec_init' returns tree structure that performs
2832    initialization of a vector of aggregate types.
2833
2834    BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2835      to the first element, of POINTER_TYPE.
2836    MAXINDEX is the maximum index of the array (one less than the
2837      number of elements).  It is only used if BASE is a pointer or
2838      TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2839
2840    INIT is the (possibly NULL) initializer.
2841
2842    If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL.  All
2843    elements in the array are value-initialized.
2844
2845    FROM_ARRAY is 0 if we should init everything with INIT
2846    (i.e., every element initialized from INIT).
2847    FROM_ARRAY is 1 if we should index into INIT in parallel
2848    with initialization of DECL.
2849    FROM_ARRAY is 2 if we should index into INIT in parallel,
2850    but use assignment instead of initialization.  */
2851
2852 tree
2853 build_vec_init (tree base, tree maxindex, tree init,
2854                 bool explicit_value_init_p,
2855                 int from_array, tsubst_flags_t complain)
2856 {
2857   tree rval;
2858   tree base2 = NULL_TREE;
2859   tree itype = NULL_TREE;
2860   tree iterator;
2861   /* The type of BASE.  */
2862   tree atype = TREE_TYPE (base);
2863   /* The type of an element in the array.  */
2864   tree type = TREE_TYPE (atype);
2865   /* The element type reached after removing all outer array
2866      types.  */
2867   tree inner_elt_type;
2868   /* The type of a pointer to an element in the array.  */
2869   tree ptype;
2870   tree stmt_expr;
2871   tree compound_stmt;
2872   int destroy_temps;
2873   tree try_block = NULL_TREE;
2874   int num_initialized_elts = 0;
2875   bool is_global;
2876   tree const_init = NULL_TREE;
2877   tree obase = base;
2878   bool xvalue = false;
2879
2880   if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
2881     maxindex = array_type_nelts (atype);
2882
2883   if (maxindex == NULL_TREE || maxindex == error_mark_node)
2884     return error_mark_node;
2885
2886   if (explicit_value_init_p)
2887     gcc_assert (!init);
2888
2889   inner_elt_type = strip_array_types (type);
2890
2891   /* Look through the TARGET_EXPR around a compound literal.  */
2892   if (init && TREE_CODE (init) == TARGET_EXPR
2893       && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
2894       && from_array != 2)
2895     init = TARGET_EXPR_INITIAL (init);
2896
2897   if (init
2898       && TREE_CODE (atype) == ARRAY_TYPE
2899       && (from_array == 2
2900           ? (!CLASS_TYPE_P (inner_elt_type)
2901              || !TYPE_HAS_COMPLEX_COPY_ASSIGN (inner_elt_type))
2902           : !TYPE_NEEDS_CONSTRUCTING (type))
2903       && ((TREE_CODE (init) == CONSTRUCTOR
2904            /* Don't do this if the CONSTRUCTOR might contain something
2905               that might throw and require us to clean up.  */
2906            && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
2907                || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2908           || from_array))
2909     {
2910       /* Do non-default initialization of trivial arrays resulting from
2911          brace-enclosed initializers.  In this case, digest_init and
2912          store_constructor will handle the semantics for us.  */
2913
2914       stmt_expr = build2 (INIT_EXPR, atype, base, init);
2915       return stmt_expr;
2916     }
2917
2918   maxindex = cp_convert (ptrdiff_type_node, maxindex);
2919   if (TREE_CODE (atype) == ARRAY_TYPE)
2920     {
2921       ptype = build_pointer_type (type);
2922       base = cp_convert (ptype, decay_conversion (base));
2923     }
2924   else
2925     ptype = atype;
2926
2927   /* The code we are generating looks like:
2928      ({
2929        T* t1 = (T*) base;
2930        T* rval = t1;
2931        ptrdiff_t iterator = maxindex;
2932        try {
2933          for (; iterator != -1; --iterator) {
2934            ... initialize *t1 ...
2935            ++t1;
2936          }
2937        } catch (...) {
2938          ... destroy elements that were constructed ...
2939        }
2940        rval;
2941      })
2942
2943      We can omit the try and catch blocks if we know that the
2944      initialization will never throw an exception, or if the array
2945      elements do not have destructors.  We can omit the loop completely if
2946      the elements of the array do not have constructors.
2947
2948      We actually wrap the entire body of the above in a STMT_EXPR, for
2949      tidiness.
2950
2951      When copying from array to another, when the array elements have
2952      only trivial copy constructors, we should use __builtin_memcpy
2953      rather than generating a loop.  That way, we could take advantage
2954      of whatever cleverness the back end has for dealing with copies
2955      of blocks of memory.  */
2956
2957   is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2958   destroy_temps = stmts_are_full_exprs_p ();
2959   current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2960   rval = get_temp_regvar (ptype, base);
2961   base = get_temp_regvar (ptype, rval);
2962   iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2963
2964   /* If initializing one array from another, initialize element by
2965      element.  We rely upon the below calls to do the argument
2966      checking.  Evaluate the initializer before entering the try block.  */
2967   if (from_array && init && TREE_CODE (init) != CONSTRUCTOR)
2968     {
2969       if (lvalue_kind (init) & clk_rvalueref)
2970         xvalue = true;
2971       base2 = decay_conversion (init);
2972       itype = TREE_TYPE (base2);
2973       base2 = get_temp_regvar (itype, base2);
2974       itype = TREE_TYPE (itype);
2975     }
2976
2977   /* Protect the entire array initialization so that we can destroy
2978      the partially constructed array if an exception is thrown.
2979      But don't do this if we're assigning.  */
2980   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2981       && from_array != 2)
2982     {
2983       try_block = begin_try_block ();
2984     }
2985
2986   /* Maybe pull out constant value when from_array? */
2987
2988   if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2989     {
2990       /* Do non-default initialization of non-trivial arrays resulting from
2991          brace-enclosed initializers.  */
2992       unsigned HOST_WIDE_INT idx;
2993       tree field, elt;
2994       /* Should we try to create a constant initializer?  */
2995       bool try_const = (literal_type_p (inner_elt_type)
2996                         || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type));
2997       bool saw_non_const = false;
2998       bool saw_const = false;
2999       /* If we're initializing a static array, we want to do static
3000          initialization of any elements with constant initializers even if
3001          some are non-constant.  */
3002       bool do_static_init = (DECL_P (obase) && TREE_STATIC (obase));
3003       VEC(constructor_elt,gc) *new_vec;
3004       from_array = 0;
3005
3006       if (try_const)
3007         new_vec = VEC_alloc (constructor_elt, gc, CONSTRUCTOR_NELTS (init));
3008       else
3009         new_vec = NULL;
3010
3011       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, field, elt)
3012         {
3013           tree baseref = build1 (INDIRECT_REF, type, base);
3014           tree one_init;
3015
3016           num_initialized_elts++;
3017
3018           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3019           if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
3020             one_init = build_aggr_init (baseref, elt, 0, complain);
3021           else
3022             one_init = cp_build_modify_expr (baseref, NOP_EXPR,
3023                                              elt, complain);
3024
3025           if (try_const)
3026             {
3027               tree e = one_init;
3028               if (TREE_CODE (e) == EXPR_STMT)
3029                 e = TREE_OPERAND (e, 0);
3030               if (TREE_CODE (e) == CONVERT_EXPR
3031                   && VOID_TYPE_P (TREE_TYPE (e)))
3032                 e = TREE_OPERAND (e, 0);
3033               e = maybe_constant_init (e);
3034               if (reduced_constant_expression_p (e))
3035                 {
3036                   CONSTRUCTOR_APPEND_ELT (new_vec, field, e);
3037                   if (do_static_init)
3038                     one_init = NULL_TREE;
3039                   else
3040                     one_init = build2 (INIT_EXPR, type, baseref, e);
3041                   saw_const = true;
3042                 }
3043               else
3044                 {
3045                   if (do_static_init)
3046                     CONSTRUCTOR_APPEND_ELT (new_vec, field,
3047                                             build_zero_init (TREE_TYPE (e),
3048                                                              NULL_TREE, true));
3049                   saw_non_const = true;
3050                 }
3051             }
3052
3053           if (one_init)
3054             finish_expr_stmt (one_init);
3055           current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3056
3057           finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
3058                                                complain));
3059           finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
3060                                                complain));
3061         }
3062
3063       if (try_const)
3064         {
3065           if (!saw_non_const)
3066             const_init = build_constructor (atype, new_vec);
3067           else if (do_static_init && saw_const)
3068             DECL_INITIAL (obase) = build_constructor (atype, new_vec);
3069           else
3070             VEC_free (constructor_elt, gc, new_vec);
3071         }
3072
3073       /* Clear out INIT so that we don't get confused below.  */
3074       init = NULL_TREE;
3075     }
3076   else if (from_array)
3077     {
3078       if (init)
3079         /* OK, we set base2 above.  */;
3080       else if (TYPE_LANG_SPECIFIC (type)
3081                && TYPE_NEEDS_CONSTRUCTING (type)
3082                && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
3083         {
3084           if (complain & tf_error)
3085             error ("initializer ends prematurely");
3086           return error_mark_node;
3087         }
3088     }
3089
3090   /* Now, default-initialize any remaining elements.  We don't need to
3091      do that if a) the type does not need constructing, or b) we've
3092      already initialized all the elements.
3093
3094      We do need to keep going if we're copying an array.  */
3095
3096   if (from_array
3097       || ((TYPE_NEEDS_CONSTRUCTING (type) || explicit_value_init_p)
3098           && ! (host_integerp (maxindex, 0)
3099                 && (num_initialized_elts
3100                     == tree_low_cst (maxindex, 0) + 1))))
3101     {
3102       /* If the ITERATOR is equal to -1, then we don't have to loop;
3103          we've already initialized all the elements.  */
3104       tree for_stmt;
3105       tree elt_init;
3106       tree to;
3107
3108       for_stmt = begin_for_stmt ();
3109       finish_for_init_stmt (for_stmt);
3110       finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
3111                                build_int_cst (TREE_TYPE (iterator), -1)),
3112                        for_stmt);
3113       finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
3114                                           complain),
3115                        for_stmt);
3116
3117       to = build1 (INDIRECT_REF, type, base);
3118
3119       if (from_array)
3120         {
3121           tree from;
3122
3123           if (base2)
3124             {
3125               from = build1 (INDIRECT_REF, itype, base2);
3126               if (xvalue)
3127                 from = move (from);
3128             }
3129           else
3130             from = NULL_TREE;
3131
3132           if (from_array == 2)
3133             elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3134                                              complain);
3135           else if (TYPE_NEEDS_CONSTRUCTING (type))
3136             elt_init = build_aggr_init (to, from, 0, complain);
3137           else if (from)
3138             elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3139                                              complain);
3140           else
3141             gcc_unreachable ();
3142         }
3143       else if (TREE_CODE (type) == ARRAY_TYPE)
3144         {
3145           if (init != 0)
3146             sorry
3147               ("cannot initialize multi-dimensional array with initializer");
3148           elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
3149                                      0, 0,
3150                                      explicit_value_init_p,
3151                                      0, complain);
3152         }
3153       else if (explicit_value_init_p)
3154         {
3155           elt_init = build_value_init (type, complain);
3156           if (elt_init == error_mark_node)
3157             return error_mark_node;
3158           else
3159             elt_init = build2 (INIT_EXPR, type, to, elt_init);
3160         }
3161       else
3162         {
3163           gcc_assert (TYPE_NEEDS_CONSTRUCTING (type));
3164           elt_init = build_aggr_init (to, init, 0, complain);
3165         }
3166
3167       current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3168       finish_expr_stmt (elt_init);
3169       current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3170
3171       finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
3172                                            complain));
3173       if (base2)
3174         finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
3175                                              complain));
3176
3177       finish_for_stmt (for_stmt);
3178     }
3179
3180   /* Make sure to cleanup any partially constructed elements.  */
3181   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3182       && from_array != 2)
3183     {
3184       tree e;
3185       tree m = cp_build_binary_op (input_location,
3186                                    MINUS_EXPR, maxindex, iterator,
3187                                    complain);
3188
3189       /* Flatten multi-dimensional array since build_vec_delete only
3190          expects one-dimensional array.  */
3191       if (TREE_CODE (type) == ARRAY_TYPE)
3192         m = cp_build_binary_op (input_location,
3193                                 MULT_EXPR, m,
3194                                 array_type_nelts_total (type),
3195                                 complain);
3196
3197       finish_cleanup_try_block (try_block);
3198       e = build_vec_delete_1 (rval, m,
3199                               inner_elt_type, sfk_base_destructor,
3200                               /*use_global_delete=*/0);
3201       finish_cleanup (e, try_block);
3202     }
3203
3204   /* The value of the array initialization is the array itself, RVAL
3205      is a pointer to the first element.  */
3206   finish_stmt_expr_expr (rval, stmt_expr);
3207
3208   stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
3209
3210   /* Now make the result have the correct type.  */
3211   if (TREE_CODE (atype) == ARRAY_TYPE)
3212     {
3213       atype = build_pointer_type (atype);
3214       stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
3215       stmt_expr = cp_build_indirect_ref (stmt_expr, RO_NULL, complain);
3216       TREE_NO_WARNING (stmt_expr) = 1;
3217     }
3218
3219   current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
3220
3221   if (const_init)
3222     return build2 (INIT_EXPR, atype, obase, const_init);
3223   return stmt_expr;
3224 }
3225
3226 /* Call the DTOR_KIND destructor for EXP.  FLAGS are as for
3227    build_delete.  */
3228
3229 static tree
3230 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
3231 {
3232   tree name;
3233   tree fn;
3234   switch (dtor_kind)
3235     {
3236     case sfk_complete_destructor:
3237       name = complete_dtor_identifier;
3238       break;
3239
3240     case sfk_base_destructor:
3241       name = base_dtor_identifier;
3242       break;
3243
3244     case sfk_deleting_destructor:
3245       name = deleting_dtor_identifier;
3246       break;
3247
3248     default:
3249       gcc_unreachable ();
3250     }
3251   fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
3252   return build_new_method_call (exp, fn,
3253                                 /*args=*/NULL,
3254                                 /*conversion_path=*/NULL_TREE,
3255                                 flags,
3256                                 /*fn_p=*/NULL,
3257                                 tf_warning_or_error);
3258 }
3259
3260 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3261    ADDR is an expression which yields the store to be destroyed.
3262    AUTO_DELETE is the name of the destructor to call, i.e., either
3263    sfk_complete_destructor, sfk_base_destructor, or
3264    sfk_deleting_destructor.
3265
3266    FLAGS is the logical disjunction of zero or more LOOKUP_
3267    flags.  See cp-tree.h for more info.  */
3268
3269 tree
3270 build_delete (tree type, tree addr, special_function_kind auto_delete,
3271     int flags, int use_global_delete)
3272 {
3273   tree expr;
3274
3275   if (addr == error_mark_node)
3276     return error_mark_node;
3277
3278   /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3279      set to `error_mark_node' before it gets properly cleaned up.  */
3280   if (type == error_mark_node)
3281     return error_mark_node;
3282
3283   type = TYPE_MAIN_VARIANT (type);
3284
3285   addr = mark_rvalue_use (addr);
3286
3287   if (TREE_CODE (type) == POINTER_TYPE)
3288     {
3289       bool complete_p = true;
3290
3291       type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3292       if (TREE_CODE (type) == ARRAY_TYPE)
3293         goto handle_array;
3294
3295       /* We don't want to warn about delete of void*, only other
3296           incomplete types.  Deleting other incomplete types
3297           invokes undefined behavior, but it is not ill-formed, so
3298           compile to something that would even do The Right Thing
3299           (TM) should the type have a trivial dtor and no delete
3300           operator.  */
3301       if (!VOID_TYPE_P (type))
3302         {
3303           complete_type (type);
3304           if (!COMPLETE_TYPE_P (type))
3305             {
3306               if (warning (0, "possible problem detected in invocation of "
3307                            "delete operator:"))
3308                 {
3309                   cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3310                   inform (input_location, "neither the destructor nor the class-specific "
3311                           "operator delete will be called, even if they are "
3312                           "declared when the class is defined.");
3313                 }
3314               complete_p = false;
3315             }
3316         }
3317       if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3318         /* Call the builtin operator delete.  */
3319         return build_builtin_delete_call (addr);
3320       if (TREE_SIDE_EFFECTS (addr))
3321         addr = save_expr (addr);
3322
3323       /* Throw away const and volatile on target type of addr.  */
3324       addr = convert_force (build_pointer_type (type), addr, 0);
3325     }
3326   else if (TREE_CODE (type) == ARRAY_TYPE)
3327     {
3328     handle_array:
3329
3330       if (TYPE_DOMAIN (type) == NULL_TREE)
3331         {
3332           error ("unknown array size in delete");
3333           return error_mark_node;
3334         }
3335       return build_vec_delete (addr, array_type_nelts (type),
3336                                auto_delete, use_global_delete);
3337     }
3338   else
3339     {
3340       /* Don't check PROTECT here; leave that decision to the
3341          destructor.  If the destructor is accessible, call it,
3342          else report error.  */
3343       addr = cp_build_addr_expr (addr, tf_warning_or_error);
3344       if (TREE_SIDE_EFFECTS (addr))
3345         addr = save_expr (addr);
3346
3347       addr = convert_force (build_pointer_type (type), addr, 0);
3348     }
3349
3350   gcc_assert (MAYBE_CLASS_TYPE_P (type));
3351
3352   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3353     {
3354       if (auto_delete != sfk_deleting_destructor)
3355         return void_zero_node;
3356
3357       return build_op_delete_call (DELETE_EXPR, addr,
3358                                    cxx_sizeof_nowarn (type),
3359                                    use_global_delete,
3360                                    /*placement=*/NULL_TREE,
3361                                    /*alloc_fn=*/NULL_TREE);
3362     }
3363   else
3364     {
3365       tree head = NULL_TREE;
3366       tree do_delete = NULL_TREE;
3367       tree ifexp;
3368
3369       if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3370         lazily_declare_fn (sfk_destructor, type);
3371
3372       /* For `::delete x', we must not use the deleting destructor
3373          since then we would not be sure to get the global `operator
3374          delete'.  */
3375       if (use_global_delete && auto_delete == sfk_deleting_destructor)
3376         {
3377           /* We will use ADDR multiple times so we must save it.  */
3378           addr = save_expr (addr);
3379           head = get_target_expr (build_headof (addr));
3380           /* Delete the object.  */
3381           do_delete = build_builtin_delete_call (head);
3382           /* Otherwise, treat this like a complete object destructor
3383              call.  */
3384           auto_delete = sfk_complete_destructor;
3385         }
3386       /* If the destructor is non-virtual, there is no deleting
3387          variant.  Instead, we must explicitly call the appropriate
3388          `operator delete' here.  */
3389       else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3390                && auto_delete == sfk_deleting_destructor)
3391         {
3392           /* We will use ADDR multiple times so we must save it.  */
3393           addr = save_expr (addr);
3394           /* Build the call.  */
3395           do_delete = build_op_delete_call (DELETE_EXPR,
3396                                             addr,
3397                                             cxx_sizeof_nowarn (type),
3398                                             /*global_p=*/false,
3399                                             /*placement=*/NULL_TREE,
3400                                             /*alloc_fn=*/NULL_TREE);
3401           /* Call the complete object destructor.  */
3402           auto_delete = sfk_complete_destructor;
3403         }
3404       else if (auto_delete == sfk_deleting_destructor
3405                && TYPE_GETS_REG_DELETE (type))
3406         {
3407           /* Make sure we have access to the member op delete, even though
3408              we'll actually be calling it from the destructor.  */
3409           build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3410                                 /*global_p=*/false,
3411                                 /*placement=*/NULL_TREE,
3412                                 /*alloc_fn=*/NULL_TREE);
3413         }
3414
3415       expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL,
3416                                                      tf_warning_or_error),
3417                               auto_delete, flags);
3418       if (do_delete)
3419         expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3420
3421       /* We need to calculate this before the dtor changes the vptr.  */
3422       if (head)
3423         expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3424
3425       if (flags & LOOKUP_DESTRUCTOR)
3426         /* Explicit destructor call; don't check for null pointer.  */
3427         ifexp = integer_one_node;
3428       else
3429         /* Handle deleting a null pointer.  */
3430         ifexp = fold (cp_build_binary_op (input_location,
3431                                           NE_EXPR, addr, integer_zero_node,
3432                                           tf_warning_or_error));
3433
3434       if (ifexp != integer_one_node)
3435         expr = build3 (COND_EXPR, void_type_node,
3436                        ifexp, expr, void_zero_node);
3437
3438       return expr;
3439     }
3440 }
3441
3442 /* At the beginning of a destructor, push cleanups that will call the
3443    destructors for our base classes and members.
3444
3445    Called from begin_destructor_body.  */
3446
3447 void
3448 push_base_cleanups (void)
3449 {
3450   tree binfo, base_binfo;
3451   int i;
3452   tree member;
3453   tree expr;
3454   VEC(tree,gc) *vbases;
3455
3456   /* Run destructors for all virtual baseclasses.  */
3457   if (CLASSTYPE_VBASECLASSES (current_class_type))
3458     {
3459       tree cond = (condition_conversion
3460                    (build2 (BIT_AND_EXPR, integer_type_node,
3461                             current_in_charge_parm,
3462                             integer_two_node)));
3463
3464       /* The CLASSTYPE_VBASECLASSES vector is in initialization
3465          order, which is also the right order for pushing cleanups.  */
3466       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3467            VEC_iterate (tree, vbases, i, base_binfo); i++)
3468         {
3469           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3470             {
3471               expr = build_special_member_call (current_class_ref,
3472                                                 base_dtor_identifier,
3473                                                 NULL,
3474                                                 base_binfo,
3475                                                 (LOOKUP_NORMAL
3476                                                  | LOOKUP_NONVIRTUAL),
3477                                                 tf_warning_or_error);
3478               expr = build3 (COND_EXPR, void_type_node, cond,
3479                              expr, void_zero_node);
3480               finish_decl_cleanup (NULL_TREE, expr);
3481             }
3482         }
3483     }
3484
3485   /* Take care of the remaining baseclasses.  */
3486   for (binfo = TYPE_BINFO (current_class_type), i = 0;
3487        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3488     {
3489       if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3490           || BINFO_VIRTUAL_P (base_binfo))
3491         continue;
3492
3493       expr = build_special_member_call (current_class_ref,
3494                                         base_dtor_identifier,
3495                                         NULL, base_binfo,
3496                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3497                                         tf_warning_or_error);
3498       finish_decl_cleanup (NULL_TREE, expr);
3499     }
3500
3501   /* Don't automatically destroy union members.  */
3502   if (TREE_CODE (current_class_type) == UNION_TYPE)
3503     return;
3504
3505   for (member = TYPE_FIELDS (current_class_type); member;
3506        member = DECL_CHAIN (member))
3507     {
3508       tree this_type = TREE_TYPE (member);
3509       if (this_type == error_mark_node
3510           || TREE_CODE (member) != FIELD_DECL
3511           || DECL_ARTIFICIAL (member))
3512         continue;
3513       if (ANON_UNION_TYPE_P (this_type))
3514         continue;
3515       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type))
3516         {
3517           tree this_member = (build_class_member_access_expr
3518                               (current_class_ref, member,
3519                                /*access_path=*/NULL_TREE,
3520                                /*preserve_reference=*/false,
3521                                tf_warning_or_error));
3522           expr = build_delete (this_type, this_member,
3523                                sfk_complete_destructor,
3524                                LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3525                                0);
3526           finish_decl_cleanup (NULL_TREE, expr);
3527         }
3528     }
3529 }
3530
3531 /* Build a C++ vector delete expression.
3532    MAXINDEX is the number of elements to be deleted.
3533    ELT_SIZE is the nominal size of each element in the vector.
3534    BASE is the expression that should yield the store to be deleted.
3535    This function expands (or synthesizes) these calls itself.
3536    AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3537
3538    This also calls delete for virtual baseclasses of elements of the vector.
3539
3540    Update: MAXINDEX is no longer needed.  The size can be extracted from the
3541    start of the vector for pointers, and from the type for arrays.  We still
3542    use MAXINDEX for arrays because it happens to already have one of the
3543    values we'd have to extract.  (We could use MAXINDEX with pointers to
3544    confirm the size, and trap if the numbers differ; not clear that it'd
3545    be worth bothering.)  */
3546
3547 tree
3548 build_vec_delete (tree base, tree maxindex,
3549     special_function_kind auto_delete_vec, int use_global_delete)
3550 {
3551   tree type;
3552   tree rval;
3553   tree base_init = NULL_TREE;
3554
3555   type = TREE_TYPE (base);
3556
3557   if (TREE_CODE (type) == POINTER_TYPE)
3558     {
3559       /* Step back one from start of vector, and read dimension.  */
3560       tree cookie_addr;
3561       tree size_ptr_type = build_pointer_type (sizetype);
3562
3563       if (TREE_SIDE_EFFECTS (base))
3564         {
3565           base_init = get_target_expr (base);
3566           base = TARGET_EXPR_SLOT (base_init);
3567         }
3568       type = strip_array_types (TREE_TYPE (type));
3569       cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
3570                                  sizetype, TYPE_SIZE_UNIT (sizetype));
3571       cookie_addr = build2 (POINTER_PLUS_EXPR,
3572                             size_ptr_type,
3573                             fold_convert (size_ptr_type, base),
3574                             cookie_addr);
3575       maxindex = cp_build_indirect_ref (cookie_addr, RO_NULL, tf_warning_or_error);
3576     }
3577   else if (TREE_CODE (type) == ARRAY_TYPE)
3578     {
3579       /* Get the total number of things in the array, maxindex is a
3580          bad name.  */
3581       maxindex = array_type_nelts_total (type);
3582       type = strip_array_types (type);
3583       base = cp_build_addr_expr (base, tf_warning_or_error);
3584       if (TREE_SIDE_EFFECTS (base))
3585         {
3586           base_init = get_target_expr (base);
3587           base = TARGET_EXPR_SLOT (base_init);
3588         }
3589     }
3590   else
3591     {
3592       if (base != error_mark_node)
3593         error ("type to vector delete is neither pointer or array type");
3594       return error_mark_node;
3595     }
3596
3597   rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3598                              use_global_delete);
3599   if (base_init)
3600     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
3601
3602   return rval;
3603 }