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