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