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