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       && TREE_CODE (init) == CONSTRUCTOR
1275       && TREE_HAS_CONSTRUCTOR (init))
1276     {
1277       /* If store_init_value returns NULL_TREE, the INIT has been
1278          record in the DECL_INITIAL for EXP.  That means there's
1279          nothing more we have to do.  */
1280       init = store_init_value (exp, init);
1281       if (init)
1282         finish_expr_stmt (init);
1283       return;
1284     }
1285
1286   /* We know that expand_default_init can handle everything we want
1287      at this point.  */
1288   expand_default_init (binfo, true_exp, exp, init, flags);
1289 }
1290
1291 /* Report an error if TYPE is not a user-defined, aggregate type.  If
1292    OR_ELSE is nonzero, give an error message.  */
1293
1294 int
1295 is_aggr_type (tree type, int or_else)
1296 {
1297   if (type == error_mark_node)
1298     return 0;
1299
1300   if (! IS_AGGR_TYPE (type)
1301       && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1302       && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
1303     {
1304       if (or_else)
1305         error ("%qT is not an aggregate type", type);
1306       return 0;
1307     }
1308   return 1;
1309 }
1310
1311 tree
1312 get_type_value (tree name)
1313 {
1314   if (name == error_mark_node)
1315     return NULL_TREE;
1316
1317   if (IDENTIFIER_HAS_TYPE_VALUE (name))
1318     return IDENTIFIER_TYPE_VALUE (name);
1319   else
1320     return NULL_TREE;
1321 }
1322
1323 /* Build a reference to a member of an aggregate.  This is not a C++
1324    `&', but really something which can have its address taken, and
1325    then act as a pointer to member, for example TYPE :: FIELD can have
1326    its address taken by saying & TYPE :: FIELD.  ADDRESS_P is true if
1327    this expression is the operand of "&".
1328
1329    @@ Prints out lousy diagnostics for operator <typename>
1330    @@ fields.
1331
1332    @@ This function should be rewritten and placed in search.c.  */
1333
1334 tree
1335 build_offset_ref (tree type, tree member, bool address_p)
1336 {
1337   tree decl;
1338   tree basebinfo = NULL_TREE;
1339
1340   /* class templates can come in as TEMPLATE_DECLs here.  */
1341   if (TREE_CODE (member) == TEMPLATE_DECL)
1342     return member;
1343
1344   if (dependent_type_p (type) || type_dependent_expression_p (member))
1345     return build_qualified_name (NULL_TREE, type, member,
1346                                  /*template_p=*/false);
1347
1348   gcc_assert (TYPE_P (type));
1349   if (! is_aggr_type (type, 1))
1350     return error_mark_node;
1351
1352   gcc_assert (DECL_P (member) || BASELINK_P (member));
1353   /* Callers should call mark_used before this point.  */
1354   gcc_assert (!DECL_P (member) || TREE_USED (member));
1355
1356   if (!COMPLETE_TYPE_P (complete_type (type))
1357       && !TYPE_BEING_DEFINED (type))
1358     {
1359       error ("incomplete type %qT does not have member %qD", type, member);
1360       return error_mark_node;
1361     }
1362
1363   /* Entities other than non-static members need no further
1364      processing.  */
1365   if (TREE_CODE (member) == TYPE_DECL)
1366     return member;
1367   if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1368     return convert_from_reference (member);
1369
1370   if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1371     {
1372       error ("invalid pointer to bit-field %qD", member);
1373       return error_mark_node;
1374     }
1375
1376   /* Set up BASEBINFO for member lookup.  */
1377   decl = maybe_dummy_object (type, &basebinfo);
1378
1379   /* A lot of this logic is now handled in lookup_member.  */
1380   if (BASELINK_P (member))
1381     {
1382       /* Go from the TREE_BASELINK to the member function info.  */
1383       tree fnfields = member;
1384       tree t = BASELINK_FUNCTIONS (fnfields);
1385
1386       if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1387         {
1388           /* Get rid of a potential OVERLOAD around it.  */
1389           t = OVL_CURRENT (t);
1390
1391           /* Unique functions are handled easily.  */
1392
1393           /* For non-static member of base class, we need a special rule
1394              for access checking [class.protected]:
1395
1396                If the access is to form a pointer to member, the
1397                nested-name-specifier shall name the derived class
1398                (or any class derived from that class).  */
1399           if (address_p && DECL_P (t)
1400               && DECL_NONSTATIC_MEMBER_P (t))
1401             perform_or_defer_access_check (TYPE_BINFO (type), t);
1402           else
1403             perform_or_defer_access_check (basebinfo, t);
1404
1405           if (DECL_STATIC_FUNCTION_P (t))
1406             return t;
1407           member = t;
1408         }
1409       else
1410         {
1411           TREE_TYPE (fnfields) = unknown_type_node;
1412           member = fnfields;
1413         }
1414     }
1415   else if (address_p && TREE_CODE (member) == FIELD_DECL)
1416     /* We need additional test besides the one in
1417        check_accessibility_of_qualified_id in case it is
1418        a pointer to non-static member.  */
1419     perform_or_defer_access_check (TYPE_BINFO (type), member);
1420
1421   if (!address_p)
1422     {
1423       /* If MEMBER is non-static, then the program has fallen afoul of
1424          [expr.prim]:
1425
1426            An id-expression that denotes a nonstatic data member or
1427            nonstatic member function of a class can only be used:
1428
1429            -- as part of a class member access (_expr.ref_) in which the
1430            object-expression refers to the member's class or a class
1431            derived from that class, or
1432
1433            -- to form a pointer to member (_expr.unary.op_), or
1434
1435            -- in the body of a nonstatic member function of that class or
1436            of a class derived from that class (_class.mfct.nonstatic_), or
1437
1438            -- in a mem-initializer for a constructor for that class or for
1439            a class derived from that class (_class.base.init_).  */
1440       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1441         {
1442           /* Build a representation of a the qualified name suitable
1443              for use as the operand to "&" -- even though the "&" is
1444              not actually present.  */
1445           member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1446           /* In Microsoft mode, treat a non-static member function as if
1447              it were a pointer-to-member.  */
1448           if (flag_ms_extensions)
1449             {
1450               PTRMEM_OK_P (member) = 1;
1451               return build_unary_op (ADDR_EXPR, member, 0);
1452             }
1453           error ("invalid use of non-static member function %qD",
1454                  TREE_OPERAND (member, 1));
1455           return member;
1456         }
1457       else if (TREE_CODE (member) == FIELD_DECL)
1458         {
1459           error ("invalid use of non-static data member %qD", member);
1460           return error_mark_node;
1461         }
1462       return member;
1463     }
1464
1465   member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1466   PTRMEM_OK_P (member) = 1;
1467   return member;
1468 }
1469
1470 /* If DECL is a scalar enumeration constant or variable with a
1471    constant initializer, return the initializer (or, its initializers,
1472    recursively); otherwise, return DECL.  If INTEGRAL_P, the
1473    initializer is only returned if DECL is an integral
1474    constant-expression.  */
1475
1476 static tree
1477 constant_value_1 (tree decl, bool integral_p)
1478 {
1479   while (TREE_CODE (decl) == CONST_DECL
1480          || (integral_p
1481              ? DECL_INTEGRAL_CONSTANT_VAR_P (decl)
1482              : (TREE_CODE (decl) == VAR_DECL
1483                 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1484     {
1485       tree init;
1486       /* Static data members in template classes may have
1487          non-dependent initializers.  References to such non-static
1488          data members are no value-dependent, so we must retrieve the
1489          initializer here.  The DECL_INITIAL will have the right type,
1490          but will not have been folded because that would prevent us
1491          from performing all appropriate semantic checks at
1492          instantiation time.  */
1493       if (DECL_CLASS_SCOPE_P (decl)
1494           && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
1495           && uses_template_parms (CLASSTYPE_TI_ARGS
1496                                   (DECL_CONTEXT (decl))))
1497         init = fold_non_dependent_expr (DECL_INITIAL (decl));
1498       else
1499         {
1500           /* If DECL is a static data member in a template
1501              specialization, we must instantiate it here.  The
1502              initializer for the static data member is not processed
1503              until needed; we need it now.  */
1504           mark_used (decl);
1505           init = DECL_INITIAL (decl);
1506         }
1507       if (!(init || init == error_mark_node)
1508           || !TREE_TYPE (init)
1509           || (integral_p
1510               ? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init))
1511               : (!TREE_CONSTANT (init)
1512                  /* Do not return an aggregate constant (of which
1513                     string literals are a special case), as we do not
1514                     want to make inadvertent copies of such entities,
1515                     and we must be sure that their addresses are the
1516                     same everywhere.  */
1517                  || TREE_CODE (init) == CONSTRUCTOR
1518                  || TREE_CODE (init) == STRING_CST)))
1519         break;
1520       decl = init;
1521     }
1522   return decl;
1523 }
1524
1525 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1526    constant of integral or enumeration type, then return that value.
1527    These are those variables permitted in constant expressions by
1528    [5.19/1].  */
1529
1530 tree
1531 integral_constant_value (tree decl)
1532 {
1533   return constant_value_1 (decl, /*integral_p=*/true);
1534 }
1535
1536 /* A more relaxed version of integral_constant_value, used by the
1537    common C/C++ code and by the C++ front-end for optimization
1538    purposes.  */
1539
1540 tree
1541 decl_constant_value (tree decl)
1542 {
1543   return constant_value_1 (decl,
1544                            /*integral_p=*/processing_template_decl);
1545 }
1546 \f
1547 /* Common subroutines of build_new and build_vec_delete.  */
1548
1549 /* Call the global __builtin_delete to delete ADDR.  */
1550
1551 static tree
1552 build_builtin_delete_call (tree addr)
1553 {
1554   mark_used (global_delete_fndecl);
1555   return build_call (global_delete_fndecl, build_tree_list (NULL_TREE, addr));
1556 }
1557 \f
1558 /* Generate a representation for a C++ "new" expression.  PLACEMENT is
1559    a TREE_LIST of placement-new arguments (or NULL_TREE if none).  If
1560    NELTS is NULL, TYPE is the type of the storage to be allocated.  If
1561    NELTS is not NULL, then this is an array-new allocation; TYPE is
1562    the type of the elements in the array and NELTS is the number of
1563    elements in the array.  INIT, if non-NULL, is the initializer for
1564    the new object.  If USE_GLOBAL_NEW is true, then the user
1565    explicitly wrote "::new" rather than just "new".  */
1566
1567 tree
1568 build_new (tree placement, tree type, tree nelts, tree init,
1569            int use_global_new)
1570 {
1571   tree rval;
1572
1573   if (type == error_mark_node)
1574     return error_mark_node;
1575
1576   if (processing_template_decl)
1577     {
1578       rval = build_min (NEW_EXPR, build_pointer_type (type),
1579                         placement, type, nelts, init);
1580       NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1581       TREE_SIDE_EFFECTS (rval) = 1;
1582       return rval;
1583     }
1584
1585   if (nelts)
1586     {
1587       if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
1588         pedwarn ("size in array new must have integral type");
1589       nelts = save_expr (cp_convert (sizetype, nelts));
1590       if (nelts == integer_zero_node)
1591         warning (0, "zero size array reserves no space");
1592     }
1593
1594   /* ``A reference cannot be created by the new operator.  A reference
1595      is not an object (8.2.2, 8.4.3), so a pointer to it could not be
1596      returned by new.'' ARM 5.3.3 */
1597   if (TREE_CODE (type) == REFERENCE_TYPE)
1598     {
1599       error ("new cannot be applied to a reference type");
1600       type = TREE_TYPE (type);
1601     }
1602
1603   if (TREE_CODE (type) == FUNCTION_TYPE)
1604     {
1605       error ("new cannot be applied to a function type");
1606       return error_mark_node;
1607     }
1608
1609   rval = build4 (NEW_EXPR, build_pointer_type (type), placement, type,
1610                  nelts, init);
1611   NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1612   TREE_SIDE_EFFECTS (rval) = 1;
1613   rval = build_new_1 (rval);
1614   if (rval == error_mark_node)
1615     return error_mark_node;
1616
1617   /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain.  */
1618   rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
1619   TREE_NO_WARNING (rval) = 1;
1620
1621   return rval;
1622 }
1623
1624 /* Given a Java class, return a decl for the corresponding java.lang.Class.  */
1625
1626 tree
1627 build_java_class_ref (tree type)
1628 {
1629   tree name = NULL_TREE, class_decl;
1630   static tree CL_suffix = NULL_TREE;
1631   if (CL_suffix == NULL_TREE)
1632     CL_suffix = get_identifier("class$");
1633   if (jclass_node == NULL_TREE)
1634     {
1635       jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
1636       if (jclass_node == NULL_TREE)
1637         fatal_error ("call to Java constructor, while %<jclass%> undefined");
1638
1639       jclass_node = TREE_TYPE (jclass_node);
1640     }
1641
1642   /* Mangle the class$ field.  */
1643   {
1644     tree field;
1645     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1646       if (DECL_NAME (field) == CL_suffix)
1647         {
1648           mangle_decl (field);
1649           name = DECL_ASSEMBLER_NAME (field);
1650           break;
1651         }
1652     if (!field)
1653       internal_error ("can't find class$");
1654     }
1655
1656   class_decl = IDENTIFIER_GLOBAL_VALUE (name);
1657   if (class_decl == NULL_TREE)
1658     {
1659       class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
1660       TREE_STATIC (class_decl) = 1;
1661       DECL_EXTERNAL (class_decl) = 1;
1662       TREE_PUBLIC (class_decl) = 1;
1663       DECL_ARTIFICIAL (class_decl) = 1;
1664       DECL_IGNORED_P (class_decl) = 1;
1665       pushdecl_top_level (class_decl);
1666       make_decl_rtl (class_decl);
1667     }
1668   return class_decl;
1669 }
1670
1671
1672 /* Called from cplus_expand_expr when expanding a NEW_EXPR.  The return
1673    value is immediately handed to expand_expr.  */
1674
1675 static tree
1676 build_new_1 (tree exp)
1677 {
1678   tree placement, init;
1679   tree size, rval;
1680   /* True iff this is a call to "operator new[]" instead of just
1681      "operator new".  */
1682   bool array_p = false;
1683   /* True iff ARRAY_P is true and the bound of the array type is
1684      not necessarily a compile time constant.  For example, VLA_P is
1685      true for "new int[f()]".  */
1686   bool vla_p = false;
1687   /* The type being allocated.  If ARRAY_P is true, this will be an
1688      ARRAY_TYPE.  */
1689   tree full_type;
1690   /* If ARRAY_P is true, the element type of the array.  This is an
1691      never ARRAY_TYPE; for something like "new int[3][4]", the
1692      ELT_TYPE is "int".  If ARRAY_P is false, this is the same type as
1693      FULL_TYPE.  */
1694   tree elt_type;
1695   /* The type of the new-expression.  (This type is always a pointer
1696      type.)  */
1697   tree pointer_type;
1698   /* The type pointed to by POINTER_TYPE.  This type may be different
1699      from ELT_TYPE for a multi-dimensional array; ELT_TYPE is never an
1700      ARRAY_TYPE, but TYPE may be an ARRAY_TYPE.  */
1701   tree type;
1702   /* A pointer type pointing to the FULL_TYPE.  */
1703   tree full_pointer_type;
1704   tree outer_nelts = NULL_TREE;
1705   tree nelts = NULL_TREE;
1706   tree alloc_call, alloc_expr;
1707   /* The address returned by the call to "operator new".  This node is
1708      a VAR_DECL and is therefore reusable.  */
1709   tree alloc_node;
1710   tree alloc_fn;
1711   tree cookie_expr, init_expr;
1712   int nothrow, check_new;
1713   /* Nonzero if the user wrote `::new' rather than just `new'.  */
1714   int globally_qualified_p;
1715   int use_java_new = 0;
1716   /* If non-NULL, the number of extra bytes to allocate at the
1717      beginning of the storage allocated for an array-new expression in
1718      order to store the number of elements.  */
1719   tree cookie_size = NULL_TREE;
1720   /* True if the function we are calling is a placement allocation
1721      function.  */
1722   bool placement_allocation_fn_p;
1723   tree args = NULL_TREE;
1724   /* True if the storage must be initialized, either by a constructor
1725      or due to an explicit new-initializer.  */
1726   bool is_initialized;
1727   /* The address of the thing allocated, not including any cookie.  In
1728      particular, if an array cookie is in use, DATA_ADDR is the
1729      address of the first array element.  This node is a VAR_DECL, and
1730      is therefore reusable.  */
1731   tree data_addr;
1732   tree init_preeval_expr = NULL_TREE;
1733
1734   placement = TREE_OPERAND (exp, 0);
1735   type = TREE_OPERAND (exp, 1);
1736   nelts = TREE_OPERAND (exp, 2);
1737   init = TREE_OPERAND (exp, 3);
1738   globally_qualified_p = NEW_EXPR_USE_GLOBAL (exp);
1739
1740   if (nelts)
1741     {
1742       tree index;
1743
1744       outer_nelts = nelts;
1745       array_p = true;
1746
1747       /* ??? The middle-end will error on us for building a VLA outside a
1748          function context.  Methinks that's not it's purvey.  So we'll do
1749          our own VLA layout later.  */
1750       vla_p = true;
1751       full_type = build_cplus_array_type (type, NULL_TREE);
1752       index = convert (sizetype, nelts);
1753       index = size_binop (MINUS_EXPR, index, size_one_node);
1754       TYPE_DOMAIN (full_type) = build_index_type (index);
1755     }
1756   else
1757     {
1758       full_type = type;
1759       if (TREE_CODE (type) == ARRAY_TYPE)
1760         {
1761           array_p = true;
1762           nelts = array_type_nelts_top (type);
1763           outer_nelts = nelts;
1764           type = TREE_TYPE (type);
1765         }
1766     }
1767
1768   if (!complete_type_or_else (type, exp))
1769     return error_mark_node;
1770
1771   /* If our base type is an array, then make sure we know how many elements
1772      it has.  */
1773   for (elt_type = type;
1774        TREE_CODE (elt_type) == ARRAY_TYPE;
1775        elt_type = TREE_TYPE (elt_type))
1776     nelts = cp_build_binary_op (MULT_EXPR, nelts,
1777                                 array_type_nelts_top (elt_type));
1778
1779   if (TREE_CODE (elt_type) == VOID_TYPE)
1780     {
1781       error ("invalid type %<void%> for new");
1782       return error_mark_node;
1783     }
1784
1785   if (abstract_virtuals_error (NULL_TREE, elt_type))
1786     return error_mark_node;
1787
1788   is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || init);
1789   if (CP_TYPE_CONST_P (elt_type) && !is_initialized)
1790     {
1791       error ("uninitialized const in %<new%> of %q#T", elt_type);
1792       return error_mark_node;
1793     }
1794
1795   size = size_in_bytes (elt_type);
1796   if (array_p)
1797     {
1798       size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1799       if (vla_p)
1800         {
1801           tree n, bitsize;
1802
1803           /* Do our own VLA layout.  Setting TYPE_SIZE/_UNIT is
1804              necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
1805              ...>> to be valid.  */
1806           TYPE_SIZE_UNIT (full_type) = size;
1807           n = convert (bitsizetype, nelts);
1808           bitsize = size_binop (MULT_EXPR, TYPE_SIZE (elt_type), n);
1809           TYPE_SIZE (full_type) = bitsize;
1810         }
1811     }
1812
1813   /* Allocate the object.  */
1814   if (! placement && TYPE_FOR_JAVA (elt_type))
1815     {
1816       tree class_addr, alloc_decl;
1817       tree class_decl = build_java_class_ref (elt_type);
1818       static const char alloc_name[] = "_Jv_AllocObject";
1819
1820       use_java_new = 1;
1821       alloc_decl = NULL;
1822       if (!get_global_value_if_present (get_identifier (alloc_name),
1823                                         &alloc_decl))
1824         {
1825           error ("call to Java constructor with %qs undefined", alloc_name);
1826           return error_mark_node;
1827         }
1828       else if (really_overloaded_fn (alloc_decl))
1829         {
1830           error ("%qD should never be overloaded", alloc_decl);
1831           return error_mark_node;
1832         }
1833       alloc_decl = OVL_CURRENT (alloc_decl);
1834       class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1835       alloc_call = (build_function_call
1836                     (alloc_decl,
1837                      build_tree_list (NULL_TREE, class_addr)));
1838     }
1839   else
1840     {
1841       tree fnname;
1842       tree fns;
1843
1844       fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
1845
1846       if (!globally_qualified_p
1847           && CLASS_TYPE_P (elt_type)
1848           && (array_p
1849               ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
1850               : TYPE_HAS_NEW_OPERATOR (elt_type)))
1851         {
1852           /* Use a class-specific operator new.  */
1853           /* If a cookie is required, add some extra space.  */
1854           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1855             {
1856               cookie_size = targetm.cxx.get_cookie_size (elt_type);
1857               size = size_binop (PLUS_EXPR, size, cookie_size);
1858             }
1859           /* Create the argument list.  */
1860           args = tree_cons (NULL_TREE, size, placement);
1861           /* Do name-lookup to find the appropriate operator.  */
1862           fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
1863           if (fns == NULL_TREE)
1864             {
1865               error ("no suitable %qD found in class %qT", fnname, elt_type);
1866               return error_mark_node;
1867             }
1868           if (TREE_CODE (fns) == TREE_LIST)
1869             {
1870               error ("request for member %qD is ambiguous", fnname);
1871               print_candidates (fns);
1872               return error_mark_node;
1873             }
1874           alloc_call = build_new_method_call (build_dummy_object (elt_type),
1875                                               fns, args,
1876                                               /*conversion_path=*/NULL_TREE,
1877                                               LOOKUP_NORMAL);
1878         }
1879       else
1880         {
1881           /* Use a global operator new.  */
1882           /* See if a cookie might be required.  */
1883           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1884             cookie_size = targetm.cxx.get_cookie_size (elt_type);
1885           else
1886             cookie_size = NULL_TREE;
1887
1888           alloc_call = build_operator_new_call (fnname, placement,
1889                                                 &size, &cookie_size);
1890         }
1891     }
1892
1893   if (alloc_call == error_mark_node)
1894     return error_mark_node;
1895
1896   /* In the simple case, we can stop now.  */
1897   pointer_type = build_pointer_type (type);
1898   if (!cookie_size && !is_initialized)
1899     return build_nop (pointer_type, alloc_call);
1900
1901   /* While we're working, use a pointer to the type we've actually
1902      allocated. Store the result of the call in a variable so that we
1903      can use it more than once.  */
1904   full_pointer_type = build_pointer_type (full_type);
1905   alloc_expr = get_target_expr (build_nop (full_pointer_type, alloc_call));
1906   alloc_node = TARGET_EXPR_SLOT (alloc_expr);
1907
1908   /* Strip any COMPOUND_EXPRs from ALLOC_CALL.  */
1909   while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
1910     alloc_call = TREE_OPERAND (alloc_call, 1);
1911   alloc_fn = get_callee_fndecl (alloc_call);
1912   gcc_assert (alloc_fn != NULL_TREE);
1913
1914   /* Now, check to see if this function is actually a placement
1915      allocation function.  This can happen even when PLACEMENT is NULL
1916      because we might have something like:
1917
1918        struct S { void* operator new (size_t, int i = 0); };
1919
1920      A call to `new S' will get this allocation function, even though
1921      there is no explicit placement argument.  If there is more than
1922      one argument, or there are variable arguments, then this is a
1923      placement allocation function.  */
1924   placement_allocation_fn_p
1925     = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
1926        || varargs_function_p (alloc_fn));
1927
1928   /* Preevaluate the placement args so that we don't reevaluate them for a
1929      placement delete.  */
1930   if (placement_allocation_fn_p)
1931     {
1932       tree inits;
1933       stabilize_call (alloc_call, &inits);
1934       if (inits)
1935         alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
1936                              alloc_expr);
1937     }
1938
1939   /*        unless an allocation function is declared with an empty  excep-
1940      tion-specification  (_except.spec_),  throw(), it indicates failure to
1941      allocate storage by throwing a bad_alloc exception  (clause  _except_,
1942      _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
1943      cation function is declared  with  an  empty  exception-specification,
1944      throw(), it returns null to indicate failure to allocate storage and a
1945      non-null pointer otherwise.
1946
1947      So check for a null exception spec on the op new we just called.  */
1948
1949   nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
1950   check_new = (flag_check_new || nothrow) && ! use_java_new;
1951
1952   if (cookie_size)
1953     {
1954       tree cookie;
1955       tree cookie_ptr;
1956
1957       /* Adjust so we're pointing to the start of the object.  */
1958       data_addr = get_target_expr (build2 (PLUS_EXPR, full_pointer_type,
1959                                            alloc_node, cookie_size));
1960
1961       /* Store the number of bytes allocated so that we can know how
1962          many elements to destroy later.  We use the last sizeof
1963          (size_t) bytes to store the number of elements.  */
1964       cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
1965                            data_addr, size_in_bytes (sizetype));
1966       cookie = build_indirect_ref (cookie_ptr, NULL);
1967
1968       cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
1969
1970       if (targetm.cxx.cookie_has_size ())
1971         {
1972           /* Also store the element size.  */
1973           cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
1974                                cookie_ptr, size_in_bytes (sizetype));
1975           cookie = build_indirect_ref (cookie_ptr, NULL);
1976           cookie = build2 (MODIFY_EXPR, sizetype, cookie,
1977                            size_in_bytes(elt_type));
1978           cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
1979                                 cookie, cookie_expr);
1980         }
1981       data_addr = TARGET_EXPR_SLOT (data_addr);
1982     }
1983   else
1984     {
1985       cookie_expr = NULL_TREE;
1986       data_addr = alloc_node;
1987     }
1988
1989   /* Now initialize the allocated object.  Note that we preevaluate the
1990      initialization expression, apart from the actual constructor call or
1991      assignment--we do this because we want to delay the allocation as long
1992      as possible in order to minimize the size of the exception region for
1993      placement delete.  */
1994   if (is_initialized)
1995     {
1996       bool stable;
1997
1998       init_expr = build_indirect_ref (data_addr, NULL);
1999
2000       if (array_p)
2001         {
2002           bool explicit_default_init_p = false;
2003
2004           if (init == void_zero_node)
2005             {
2006               init = NULL_TREE;
2007               explicit_default_init_p = true;
2008             }
2009           else if (init)
2010             pedwarn ("ISO C++ forbids initialization in array new");
2011
2012           init_expr
2013             = build_vec_init (init_expr,
2014                               cp_build_binary_op (MINUS_EXPR, outer_nelts,
2015                                                   integer_one_node),
2016                               init,
2017                               explicit_default_init_p,
2018                               /*from_array=*/0);
2019
2020           /* An array initialization is stable because the initialization
2021              of each element is a full-expression, so the temporaries don't
2022              leak out.  */
2023           stable = true;
2024         }
2025       else
2026         {
2027           if (init == void_zero_node)
2028             init = build_default_init (full_type, nelts);
2029
2030           if (TYPE_NEEDS_CONSTRUCTING (type))
2031             {
2032               init_expr = build_special_member_call (init_expr,
2033                                                      complete_ctor_identifier,
2034                                                      init, elt_type,
2035                                                      LOOKUP_NORMAL);
2036               stable = stabilize_init (init_expr, &init_preeval_expr);
2037             }
2038           else
2039             {
2040               /* We are processing something like `new int (10)', which
2041                  means allocate an int, and initialize it with 10.  */
2042
2043               if (TREE_CODE (init) == TREE_LIST)
2044                 init = build_x_compound_expr_from_list (init,
2045                                                         "new initializer");
2046               else
2047                 gcc_assert (TREE_CODE (init) != CONSTRUCTOR
2048                             || TREE_TYPE (init) != NULL_TREE);
2049
2050               init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
2051               stable = stabilize_init (init_expr, &init_preeval_expr);
2052             }
2053         }
2054
2055       if (init_expr == error_mark_node)
2056         return error_mark_node;
2057
2058       /* If any part of the object initialization terminates by throwing an
2059          exception and a suitable deallocation function can be found, the
2060          deallocation function is called to free the memory in which the
2061          object was being constructed, after which the exception continues
2062          to propagate in the context of the new-expression. If no
2063          unambiguous matching deallocation function can be found,
2064          propagating the exception does not cause the object's memory to be
2065          freed.  */
2066       if (flag_exceptions && ! use_java_new)
2067         {
2068           enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2069           tree cleanup;
2070
2071           /* The Standard is unclear here, but the right thing to do
2072              is to use the same method for finding deallocation
2073              functions that we use for finding allocation functions.  */
2074           cleanup = build_op_delete_call (dcode, alloc_node, size,
2075                                           globally_qualified_p,
2076                                           (placement_allocation_fn_p
2077                                            ? alloc_call : NULL_TREE));
2078
2079           if (!cleanup)
2080             /* We're done.  */;
2081           else if (stable)
2082             /* This is much simpler if we were able to preevaluate all of
2083                the arguments to the constructor call.  */
2084             init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2085                                 init_expr, cleanup);
2086           else
2087             /* Ack!  First we allocate the memory.  Then we set our sentry
2088                variable to true, and expand a cleanup that deletes the
2089                memory if sentry is true.  Then we run the constructor, and
2090                finally clear the sentry.
2091
2092                We need to do this because we allocate the space first, so
2093                if there are any temporaries with cleanups in the
2094                constructor args and we weren't able to preevaluate them, we
2095                need this EH region to extend until end of full-expression
2096                to preserve nesting.  */
2097             {
2098               tree end, sentry, begin;
2099
2100               begin = get_target_expr (boolean_true_node);
2101               CLEANUP_EH_ONLY (begin) = 1;
2102
2103               sentry = TARGET_EXPR_SLOT (begin);
2104
2105               TARGET_EXPR_CLEANUP (begin)
2106                 = build3 (COND_EXPR, void_type_node, sentry,
2107                           cleanup, void_zero_node);
2108
2109               end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2110                             sentry, boolean_false_node);
2111
2112               init_expr
2113                 = build2 (COMPOUND_EXPR, void_type_node, begin,
2114                           build2 (COMPOUND_EXPR, void_type_node, init_expr,
2115                                   end));
2116             }
2117
2118         }
2119     }
2120   else
2121     init_expr = NULL_TREE;
2122
2123   /* Now build up the return value in reverse order.  */
2124
2125   rval = data_addr;
2126
2127   if (init_expr)
2128     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2129   if (cookie_expr)
2130     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2131
2132   if (rval == alloc_node)
2133     /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2134        and return the call (which doesn't need to be adjusted).  */
2135     rval = TARGET_EXPR_INITIAL (alloc_expr);
2136   else
2137     {
2138       if (check_new)
2139         {
2140           tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
2141                                            integer_zero_node);
2142           rval = build_conditional_expr (ifexp, rval, alloc_node);
2143         }
2144
2145       /* Perform the allocation before anything else, so that ALLOC_NODE
2146          has been initialized before we start using it.  */
2147       rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2148     }
2149
2150   if (init_preeval_expr)
2151     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2152
2153   /* Convert to the final type.  */
2154   rval = build_nop (pointer_type, rval);
2155
2156   /* A new-expression is never an lvalue.  */
2157   rval = rvalue (rval);
2158
2159   return rval;
2160 }
2161 \f
2162 static tree
2163 build_vec_delete_1 (tree base, tree maxindex, tree type,
2164     special_function_kind auto_delete_vec, int use_global_delete)
2165 {
2166   tree virtual_size;
2167   tree ptype = build_pointer_type (type = complete_type (type));
2168   tree size_exp = size_in_bytes (type);
2169
2170   /* Temporary variables used by the loop.  */
2171   tree tbase, tbase_init;
2172
2173   /* This is the body of the loop that implements the deletion of a
2174      single element, and moves temp variables to next elements.  */
2175   tree body;
2176
2177   /* This is the LOOP_EXPR that governs the deletion of the elements.  */
2178   tree loop = 0;
2179
2180   /* This is the thing that governs what to do after the loop has run.  */
2181   tree deallocate_expr = 0;
2182
2183   /* This is the BIND_EXPR which holds the outermost iterator of the
2184      loop.  It is convenient to set this variable up and test it before
2185      executing any other code in the loop.
2186      This is also the containing expression returned by this function.  */
2187   tree controller = NULL_TREE;
2188
2189   /* We should only have 1-D arrays here.  */
2190   gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2191
2192   if (! IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2193     goto no_destructor;
2194
2195   /* The below is short by the cookie size.  */
2196   virtual_size = size_binop (MULT_EXPR, size_exp,
2197                              convert (sizetype, maxindex));
2198
2199   tbase = create_temporary_var (ptype);
2200   tbase_init = build_modify_expr (tbase, NOP_EXPR,
2201                                   fold_build2 (PLUS_EXPR, ptype,
2202                                                base,
2203                                                virtual_size));
2204   DECL_REGISTER (tbase) = 1;
2205   controller = build3 (BIND_EXPR, void_type_node, tbase,
2206                        NULL_TREE, NULL_TREE);
2207   TREE_SIDE_EFFECTS (controller) = 1;
2208
2209   body = build1 (EXIT_EXPR, void_type_node,
2210                  build2 (EQ_EXPR, boolean_type_node, base, tbase));
2211   body = build_compound_expr
2212     (body, build_modify_expr (tbase, NOP_EXPR,
2213                               build2 (MINUS_EXPR, ptype, tbase, size_exp)));
2214   body = build_compound_expr
2215     (body, build_delete (ptype, tbase, sfk_complete_destructor,
2216                          LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2217
2218   loop = build1 (LOOP_EXPR, void_type_node, body);
2219   loop = build_compound_expr (tbase_init, loop);
2220
2221  no_destructor:
2222   /* If the delete flag is one, or anything else with the low bit set,
2223      delete the storage.  */
2224   if (auto_delete_vec != sfk_base_destructor)
2225     {
2226       tree base_tbd;
2227
2228       /* The below is short by the cookie size.  */
2229       virtual_size = size_binop (MULT_EXPR, size_exp,
2230                                  convert (sizetype, maxindex));
2231
2232       if (! TYPE_VEC_NEW_USES_COOKIE (type))
2233         /* no header */
2234         base_tbd = base;
2235       else
2236         {
2237           tree cookie_size;
2238
2239           cookie_size = targetm.cxx.get_cookie_size (type);
2240           base_tbd
2241             = cp_convert (ptype,
2242                           cp_build_binary_op (MINUS_EXPR,
2243                                               cp_convert (string_type_node,
2244                                                           base),
2245                                               cookie_size));
2246           /* True size with header.  */
2247           virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2248         }
2249
2250       if (auto_delete_vec == sfk_deleting_destructor)
2251         deallocate_expr = build_x_delete (base_tbd,
2252                                           2 | use_global_delete,
2253                                           virtual_size);
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 /* Free up storage of type TYPE, at address ADDR.
2614
2615    TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2616    of pointer.
2617
2618    VIRTUAL_SIZE is the amount of storage that was allocated, and is
2619    used as the second argument to operator delete.  It can include
2620    things like padding and magic size cookies.  It has virtual in it,
2621    because if you have a base pointer and you delete through a virtual
2622    destructor, it should be the size of the dynamic object, not the
2623    static object, see Free Store 12.5 ISO C++.
2624
2625    This does not call any destructors.  */
2626
2627 tree
2628 build_x_delete (tree addr, int which_delete, tree virtual_size)
2629 {
2630   int use_global_delete = which_delete & 1;
2631   int use_vec_delete = !!(which_delete & 2);
2632   enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
2633
2634   return build_op_delete_call (code, addr, virtual_size, use_global_delete,
2635                                NULL_TREE);
2636 }
2637
2638 /* Call the DTOR_KIND destructor for EXP.  FLAGS are as for
2639    build_delete.  */
2640
2641 static tree
2642 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2643 {
2644   tree name;
2645   tree fn;
2646   switch (dtor_kind)
2647     {
2648     case sfk_complete_destructor:
2649       name = complete_dtor_identifier;
2650       break;
2651
2652     case sfk_base_destructor:
2653       name = base_dtor_identifier;
2654       break;
2655
2656     case sfk_deleting_destructor:
2657       name = deleting_dtor_identifier;
2658       break;
2659
2660     default:
2661       gcc_unreachable ();
2662     }
2663   fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2664   return build_new_method_call (exp, fn,
2665                                 /*args=*/NULL_TREE,
2666                                 /*conversion_path=*/NULL_TREE,
2667                                 flags);
2668 }
2669
2670 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2671    ADDR is an expression which yields the store to be destroyed.
2672    AUTO_DELETE is the name of the destructor to call, i.e., either
2673    sfk_complete_destructor, sfk_base_destructor, or
2674    sfk_deleting_destructor.
2675
2676    FLAGS is the logical disjunction of zero or more LOOKUP_
2677    flags.  See cp-tree.h for more info.  */
2678
2679 tree
2680 build_delete (tree type, tree addr, special_function_kind auto_delete,
2681     int flags, int use_global_delete)
2682 {
2683   tree expr;
2684
2685   if (addr == error_mark_node)
2686     return error_mark_node;
2687
2688   /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2689      set to `error_mark_node' before it gets properly cleaned up.  */
2690   if (type == error_mark_node)
2691     return error_mark_node;
2692
2693   type = TYPE_MAIN_VARIANT (type);
2694
2695   if (TREE_CODE (type) == POINTER_TYPE)
2696     {
2697       bool complete_p = true;
2698
2699       type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2700       if (TREE_CODE (type) == ARRAY_TYPE)
2701         goto handle_array;
2702
2703       /* We don't want to warn about delete of void*, only other
2704           incomplete types.  Deleting other incomplete types
2705           invokes undefined behavior, but it is not ill-formed, so
2706           compile to something that would even do The Right Thing
2707           (TM) should the type have a trivial dtor and no delete
2708           operator.  */
2709       if (!VOID_TYPE_P (type))
2710         {
2711           complete_type (type);
2712           if (!COMPLETE_TYPE_P (type))
2713             {
2714               warning (0, "possible problem detected in invocation of "
2715                        "delete operator:");
2716               cxx_incomplete_type_diagnostic (addr, type, 1);
2717               inform ("neither the destructor nor the class-specific "
2718                       "operator delete will be called, even if they are "
2719                       "declared when the class is defined.");
2720               complete_p = false;
2721             }
2722         }
2723       if (VOID_TYPE_P (type) || !complete_p || !IS_AGGR_TYPE (type))
2724         /* Call the builtin operator delete.  */
2725         return build_builtin_delete_call (addr);
2726       if (TREE_SIDE_EFFECTS (addr))
2727         addr = save_expr (addr);
2728
2729       /* Throw away const and volatile on target type of addr.  */
2730       addr = convert_force (build_pointer_type (type), addr, 0);
2731     }
2732   else if (TREE_CODE (type) == ARRAY_TYPE)
2733     {
2734     handle_array:
2735
2736       if (TYPE_DOMAIN (type) == NULL_TREE)
2737         {
2738           error ("unknown array size in delete");
2739           return error_mark_node;
2740         }
2741       return build_vec_delete (addr, array_type_nelts (type),
2742                                auto_delete, use_global_delete);
2743     }
2744   else
2745     {
2746       /* Don't check PROTECT here; leave that decision to the
2747          destructor.  If the destructor is accessible, call it,
2748          else report error.  */
2749       addr = build_unary_op (ADDR_EXPR, addr, 0);
2750       if (TREE_SIDE_EFFECTS (addr))
2751         addr = save_expr (addr);
2752
2753       addr = convert_force (build_pointer_type (type), addr, 0);
2754     }
2755
2756   gcc_assert (IS_AGGR_TYPE (type));
2757
2758   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2759     {
2760       if (auto_delete != sfk_deleting_destructor)
2761         return void_zero_node;
2762
2763       return build_op_delete_call
2764         (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), use_global_delete,
2765          NULL_TREE);
2766     }
2767   else
2768     {
2769       tree do_delete = NULL_TREE;
2770       tree ifexp;
2771
2772       if (CLASSTYPE_LAZY_DESTRUCTOR (type))
2773         lazily_declare_fn (sfk_destructor, type);
2774
2775       /* For `::delete x', we must not use the deleting destructor
2776          since then we would not be sure to get the global `operator
2777          delete'.  */
2778       if (use_global_delete && auto_delete == sfk_deleting_destructor)
2779         {
2780           /* We will use ADDR multiple times so we must save it.  */
2781           addr = save_expr (addr);
2782           /* Delete the object.  */
2783           do_delete = build_builtin_delete_call (addr);
2784           /* Otherwise, treat this like a complete object destructor
2785              call.  */
2786           auto_delete = sfk_complete_destructor;
2787         }
2788       /* If the destructor is non-virtual, there is no deleting
2789          variant.  Instead, we must explicitly call the appropriate
2790          `operator delete' here.  */
2791       else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
2792                && auto_delete == sfk_deleting_destructor)
2793         {
2794           /* We will use ADDR multiple times so we must save it.  */
2795           addr = save_expr (addr);
2796           /* Build the call.  */
2797           do_delete = build_op_delete_call (DELETE_EXPR,
2798                                             addr,
2799                                             cxx_sizeof_nowarn (type),
2800                                             /*global_p=*/false,
2801                                             NULL_TREE);
2802           /* Call the complete object destructor.  */
2803           auto_delete = sfk_complete_destructor;
2804         }
2805       else if (auto_delete == sfk_deleting_destructor
2806                && TYPE_GETS_REG_DELETE (type))
2807         {
2808           /* Make sure we have access to the member op delete, even though
2809              we'll actually be calling it from the destructor.  */
2810           build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
2811                                 /*global_p=*/false, NULL_TREE);
2812         }
2813
2814       expr = build_dtor_call (build_indirect_ref (addr, NULL),
2815                               auto_delete, flags);
2816       if (do_delete)
2817         expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
2818
2819       if (flags & LOOKUP_DESTRUCTOR)
2820         /* Explicit destructor call; don't check for null pointer.  */
2821         ifexp = integer_one_node;
2822       else
2823         /* Handle deleting a null pointer.  */
2824         ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
2825
2826       if (ifexp != integer_one_node)
2827         expr = build3 (COND_EXPR, void_type_node,
2828                        ifexp, expr, void_zero_node);
2829
2830       return expr;
2831     }
2832 }
2833
2834 /* At the beginning of a destructor, push cleanups that will call the
2835    destructors for our base classes and members.
2836
2837    Called from begin_destructor_body.  */
2838
2839 void
2840 push_base_cleanups (void)
2841 {
2842   tree binfo, base_binfo;
2843   int i;
2844   tree member;
2845   tree expr;
2846   VEC(tree,gc) *vbases;
2847
2848   /* Run destructors for all virtual baseclasses.  */
2849   if (CLASSTYPE_VBASECLASSES (current_class_type))
2850     {
2851       tree cond = (condition_conversion
2852                    (build2 (BIT_AND_EXPR, integer_type_node,
2853                             current_in_charge_parm,
2854                             integer_two_node)));
2855
2856       /* The CLASSTYPE_VBASECLASSES vector is in initialization
2857          order, which is also the right order for pushing cleanups.  */
2858       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
2859            VEC_iterate (tree, vbases, i, base_binfo); i++)
2860         {
2861           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
2862             {
2863               expr = build_special_member_call (current_class_ref,
2864                                                 base_dtor_identifier,
2865                                                 NULL_TREE,
2866                                                 base_binfo,
2867                                                 (LOOKUP_NORMAL
2868                                                  | LOOKUP_NONVIRTUAL));
2869               expr = build3 (COND_EXPR, void_type_node, cond,
2870                              expr, void_zero_node);
2871               finish_decl_cleanup (NULL_TREE, expr);
2872             }
2873         }
2874     }
2875
2876   /* Take care of the remaining baseclasses.  */
2877   for (binfo = TYPE_BINFO (current_class_type), i = 0;
2878        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2879     {
2880       if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
2881           || BINFO_VIRTUAL_P (base_binfo))
2882         continue;
2883
2884       expr = build_special_member_call (current_class_ref,
2885                                         base_dtor_identifier,
2886                                         NULL_TREE, base_binfo,
2887                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
2888       finish_decl_cleanup (NULL_TREE, expr);
2889     }
2890
2891   for (member = TYPE_FIELDS (current_class_type); member;
2892        member = TREE_CHAIN (member))
2893     {
2894       if (TREE_CODE (member) != FIELD_DECL || DECL_ARTIFICIAL (member))
2895         continue;
2896       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
2897         {
2898           tree this_member = (build_class_member_access_expr
2899                               (current_class_ref, member,
2900                                /*access_path=*/NULL_TREE,
2901                                /*preserve_reference=*/false));
2902           tree this_type = TREE_TYPE (member);
2903           expr = build_delete (this_type, this_member,
2904                                sfk_complete_destructor,
2905                                LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
2906                                0);
2907           finish_decl_cleanup (NULL_TREE, expr);
2908         }
2909     }
2910 }
2911
2912 /* Build a C++ vector delete expression.
2913    MAXINDEX is the number of elements to be deleted.
2914    ELT_SIZE is the nominal size of each element in the vector.
2915    BASE is the expression that should yield the store to be deleted.
2916    This function expands (or synthesizes) these calls itself.
2917    AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
2918
2919    This also calls delete for virtual baseclasses of elements of the vector.
2920
2921    Update: MAXINDEX is no longer needed.  The size can be extracted from the
2922    start of the vector for pointers, and from the type for arrays.  We still
2923    use MAXINDEX for arrays because it happens to already have one of the
2924    values we'd have to extract.  (We could use MAXINDEX with pointers to
2925    confirm the size, and trap if the numbers differ; not clear that it'd
2926    be worth bothering.)  */
2927
2928 tree
2929 build_vec_delete (tree base, tree maxindex,
2930     special_function_kind auto_delete_vec, int use_global_delete)
2931 {
2932   tree type;
2933   tree rval;
2934   tree base_init = NULL_TREE;
2935
2936   type = TREE_TYPE (base);
2937
2938   if (TREE_CODE (type) == POINTER_TYPE)
2939     {
2940       /* Step back one from start of vector, and read dimension.  */
2941       tree cookie_addr;
2942
2943       if (TREE_SIDE_EFFECTS (base))
2944         {
2945           base_init = get_target_expr (base);
2946           base = TARGET_EXPR_SLOT (base_init);
2947         }
2948       type = strip_array_types (TREE_TYPE (type));
2949       cookie_addr = build2 (MINUS_EXPR,
2950                             build_pointer_type (sizetype),
2951                             base,
2952                             TYPE_SIZE_UNIT (sizetype));
2953       maxindex = build_indirect_ref (cookie_addr, NULL);
2954     }
2955   else if (TREE_CODE (type) == ARRAY_TYPE)
2956     {
2957       /* Get the total number of things in the array, maxindex is a
2958          bad name.  */
2959       maxindex = array_type_nelts_total (type);
2960       type = strip_array_types (type);
2961       base = build_unary_op (ADDR_EXPR, base, 1);
2962       if (TREE_SIDE_EFFECTS (base))
2963         {
2964           base_init = get_target_expr (base);
2965           base = TARGET_EXPR_SLOT (base_init);
2966         }
2967     }
2968   else
2969     {
2970       if (base != error_mark_node)
2971         error ("type to vector delete is neither pointer or array type");
2972       return error_mark_node;
2973     }
2974
2975   rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
2976                              use_global_delete);
2977   if (base_init)
2978     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
2979
2980   return rval;
2981 }