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