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