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