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 %qD is not a direct or virtual base of %qT",
1023                    name, current_class_type);
1024           else
1025             error ("type %qD is not a direct base of %qT",
1026                    name, 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 name, bool address_p)
1336 {
1337   tree decl;
1338   tree member;
1339   tree basebinfo = NULL_TREE;
1340   tree orig_name = name;
1341
1342   /* class templates can come in as TEMPLATE_DECLs here.  */
1343   if (TREE_CODE (name) == TEMPLATE_DECL)
1344     return name;
1345
1346   if (dependent_type_p (type) || type_dependent_expression_p (name))
1347     return build_min_nt (SCOPE_REF, type, name);
1348
1349   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1350     {
1351       /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1352          something like `a.template f<int>' or the like.  For the most
1353          part, we treat this just like a.f.  We do remember, however,
1354          the template-id that was used.  */
1355       name = TREE_OPERAND (orig_name, 0);
1356
1357       if (DECL_P (name))
1358         name = DECL_NAME (name);
1359       else
1360         {
1361           if (TREE_CODE (name) == COMPONENT_REF)
1362             name = TREE_OPERAND (name, 1);
1363           if (TREE_CODE (name) == OVERLOAD)
1364             name = DECL_NAME (OVL_CURRENT (name));
1365         }
1366
1367       gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1368     }
1369
1370   if (type == NULL_TREE)
1371     return error_mark_node;
1372
1373   /* Handle namespace names fully here.  */
1374   if (TREE_CODE (type) == NAMESPACE_DECL)
1375     {
1376       tree t = lookup_namespace_name (type, name);
1377       if (t == error_mark_node)
1378         return t;
1379       if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1380         /* Reconstruct the TEMPLATE_ID_EXPR.  */
1381         t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t),
1382                     t, TREE_OPERAND (orig_name, 1));
1383       if (! type_unknown_p (t))
1384         {
1385           mark_used (t);
1386           t = convert_from_reference (t);
1387         }
1388       return t;
1389     }
1390
1391   if (! is_aggr_type (type, 1))
1392     return error_mark_node;
1393
1394   if (TREE_CODE (name) == BIT_NOT_EXPR)
1395     {
1396       if (! check_dtor_name (type, name))
1397         error ("qualified type %qT does not match destructor name %<~%T%>",
1398                   type, TREE_OPERAND (name, 0));
1399       name = dtor_identifier;
1400     }
1401
1402   if (!COMPLETE_TYPE_P (complete_type (type))
1403       && !TYPE_BEING_DEFINED (type))
1404     {
1405       error ("incomplete type %qT does not have member %qD", type, name);
1406       return error_mark_node;
1407     }
1408
1409   /* Set up BASEBINFO for member lookup.  */
1410   decl = maybe_dummy_object (type, &basebinfo);
1411
1412   if (BASELINK_P (name) || DECL_P (name))
1413     member = name;
1414   else
1415     {
1416       member = lookup_member (basebinfo, name, 1, 0);
1417
1418       if (member == error_mark_node)
1419         return error_mark_node;
1420     }
1421
1422   if (!member)
1423     {
1424       error ("%qD is not a member of type %qT", name, type);
1425       return error_mark_node;
1426     }
1427
1428   if (TREE_CODE (member) == TYPE_DECL)
1429     {
1430       TREE_USED (member) = 1;
1431       return member;
1432     }
1433   /* static class members and class-specific enum
1434      values can be returned without further ado.  */
1435   if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1436     {
1437       mark_used (member);
1438       return convert_from_reference (member);
1439     }
1440
1441   if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1442     {
1443       error ("invalid pointer to bit-field %qD", member);
1444       return error_mark_node;
1445     }
1446
1447   /* A lot of this logic is now handled in lookup_member.  */
1448   if (BASELINK_P (member))
1449     {
1450       /* Go from the TREE_BASELINK to the member function info.  */
1451       tree fnfields = member;
1452       tree t = BASELINK_FUNCTIONS (fnfields);
1453
1454       if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1455         {
1456           /* The FNFIELDS are going to contain functions that aren't
1457              necessarily templates, and templates that don't
1458              necessarily match the explicit template parameters.  We
1459              save all the functions, and the explicit parameters, and
1460              then figure out exactly what to instantiate with what
1461              arguments in instantiate_type.  */
1462
1463           if (TREE_CODE (t) != OVERLOAD)
1464             /* The code in instantiate_type which will process this
1465                expects to encounter OVERLOADs, not raw functions.  */
1466             t = ovl_cons (t, NULL_TREE);
1467
1468           t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t), t,
1469                       TREE_OPERAND (orig_name, 1));
1470           t = build2 (OFFSET_REF, unknown_type_node, decl, t);
1471
1472           PTRMEM_OK_P (t) = 1;
1473
1474           return t;
1475         }
1476
1477       if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1478         {
1479           /* Get rid of a potential OVERLOAD around it.  */
1480           t = OVL_CURRENT (t);
1481
1482           /* Unique functions are handled easily.  */
1483
1484           /* For non-static member of base class, we need a special rule
1485              for access checking [class.protected]:
1486
1487                If the access is to form a pointer to member, the
1488                nested-name-specifier shall name the derived class
1489                (or any class derived from that class).  */
1490           if (address_p && DECL_P (t)
1491               && DECL_NONSTATIC_MEMBER_P (t))
1492             perform_or_defer_access_check (TYPE_BINFO (type), t);
1493           else
1494             perform_or_defer_access_check (basebinfo, t);
1495
1496           mark_used (t);
1497           if (DECL_STATIC_FUNCTION_P (t))
1498             return t;
1499           member = t;
1500         }
1501       else
1502         {
1503           TREE_TYPE (fnfields) = unknown_type_node;
1504           member = fnfields;
1505         }
1506     }
1507   else if (address_p && TREE_CODE (member) == FIELD_DECL)
1508     /* We need additional test besides the one in
1509        check_accessibility_of_qualified_id in case it is
1510        a pointer to non-static member.  */
1511     perform_or_defer_access_check (TYPE_BINFO (type), member);
1512
1513   if (!address_p)
1514     {
1515       /* If MEMBER is non-static, then the program has fallen afoul of
1516          [expr.prim]:
1517
1518            An id-expression that denotes a nonstatic data member or
1519            nonstatic member function of a class can only be used:
1520
1521            -- as part of a class member access (_expr.ref_) in which the
1522            object-expression refers to the member's class or a class
1523            derived from that class, or
1524
1525            -- to form a pointer to member (_expr.unary.op_), or
1526
1527            -- in the body of a nonstatic member function of that class or
1528            of a class derived from that class (_class.mfct.nonstatic_), or
1529
1530            -- in a mem-initializer for a constructor for that class or for
1531            a class derived from that class (_class.base.init_).  */
1532       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1533         {
1534           /* Build a representation of a the qualified name suitable
1535              for use as the operand to "&" -- even though the "&" is
1536              not actually present.  */
1537           member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1538           /* In Microsoft mode, treat a non-static member function as if
1539              it were a pointer-to-member.  */
1540           if (flag_ms_extensions)
1541             {
1542               PTRMEM_OK_P (member) = 1;
1543               return build_unary_op (ADDR_EXPR, member, 0);
1544             }
1545           error ("invalid use of non-static member function %qD",
1546                  TREE_OPERAND (member, 1));
1547           return member;
1548         }
1549       else if (TREE_CODE (member) == FIELD_DECL)
1550         {
1551           error ("invalid use of non-static data member %qD", member);
1552           return error_mark_node;
1553         }
1554       return member;
1555     }
1556
1557   member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1558   PTRMEM_OK_P (member) = 1;
1559   return member;
1560 }
1561
1562 /* If DECL is a scalar enumeration constant or variable with a
1563    constant initializer, return the initializer (or, its initializers,
1564    recursively); otherwise, return DECL.  If INTEGRAL_P, the
1565    initializer is only returned if DECL is an integral
1566    constant-expression.  */
1567
1568 static tree
1569 constant_value_1 (tree decl, bool integral_p)
1570 {
1571   while (TREE_CODE (decl) == CONST_DECL
1572          || (integral_p
1573              ? DECL_INTEGRAL_CONSTANT_VAR_P (decl)
1574              : (TREE_CODE (decl) == VAR_DECL
1575                 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1576     {
1577       tree init;
1578       /* If DECL is a static data member in a template class, we must
1579          instantiate it here.  The initializer for the static data
1580          member is not processed until needed; we need it now.  */
1581       mark_used (decl);
1582       init = DECL_INITIAL (decl);
1583       /* If we are currently processing a template, the
1584          initializer for a static data member may not be dependent,
1585          but it is not folded until instantiation time.  */
1586       if (init)
1587         init = fold_non_dependent_expr (init);
1588       if (!(init || init == error_mark_node)
1589           || !TREE_TYPE (init)
1590           || (integral_p
1591               ? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init))
1592               : (!TREE_CONSTANT (init)
1593                  /* Do not return an aggregate constant (of which
1594                     string literals are a special case), as we do not
1595                     want to make inadvertant copies of such entities,
1596                     and we must be sure that their addresses are the
1597                     same everywhere.  */
1598                  || TREE_CODE (init) == CONSTRUCTOR
1599                  || TREE_CODE (init) == STRING_CST)))
1600         break;
1601       decl = init;
1602     }
1603   return decl;
1604 }
1605
1606 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1607    constant of integral or enumeration type, then return that value.
1608    These are those variables permitted in constant expressions by
1609    [5.19/1].  */
1610
1611 tree
1612 integral_constant_value (tree decl)
1613 {
1614   return constant_value_1 (decl, /*integral_p=*/true);
1615 }
1616
1617 /* A more relaxed version of integral_constant_value, used by the
1618    common C/C++ code and by the C++ front-end for optimization
1619    purposes.  */
1620
1621 tree
1622 decl_constant_value (tree decl)
1623 {
1624   return constant_value_1 (decl,
1625                            /*integral_p=*/processing_template_decl);
1626 }
1627 \f
1628 /* Common subroutines of build_new and build_vec_delete.  */
1629
1630 /* Call the global __builtin_delete to delete ADDR.  */
1631
1632 static tree
1633 build_builtin_delete_call (tree addr)
1634 {
1635   mark_used (global_delete_fndecl);
1636   return build_call (global_delete_fndecl, build_tree_list (NULL_TREE, addr));
1637 }
1638 \f
1639 /* Generate a representation for a C++ "new" expression.  PLACEMENT is
1640    a TREE_LIST of placement-new arguments (or NULL_TREE if none).  If
1641    NELTS is NULL, TYPE is the type of the storage to be allocated.  If
1642    NELTS is not NULL, then this is an array-new allocation; TYPE is
1643    the type of the elements in the array and NELTS is the number of
1644    elements in the array.  INIT, if non-NULL, is the initializer for
1645    the new object.  If USE_GLOBAL_NEW is true, then the user
1646    explicitly wrote "::new" rather than just "new".  */
1647
1648 tree
1649 build_new (tree placement, tree type, tree nelts, tree init,
1650            int use_global_new)
1651 {
1652   tree rval;
1653
1654   if (type == error_mark_node)
1655     return error_mark_node;
1656
1657   if (processing_template_decl)
1658     {
1659       rval = build_min (NEW_EXPR, build_pointer_type (type),
1660                         placement, type, nelts, init);
1661       NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1662       TREE_SIDE_EFFECTS (rval) = 1;
1663       return rval;
1664     }
1665
1666   if (nelts)
1667     {
1668       if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
1669         pedwarn ("size in array new must have integral type");
1670       nelts = save_expr (cp_convert (sizetype, nelts));
1671       if (nelts == integer_zero_node)
1672         warning (0, "zero size array reserves no space");
1673     }
1674
1675   /* ``A reference cannot be created by the new operator.  A reference
1676      is not an object (8.2.2, 8.4.3), so a pointer to it could not be
1677      returned by new.'' ARM 5.3.3 */
1678   if (TREE_CODE (type) == REFERENCE_TYPE)
1679     {
1680       error ("new cannot be applied to a reference type");
1681       type = TREE_TYPE (type);
1682     }
1683
1684   if (TREE_CODE (type) == FUNCTION_TYPE)
1685     {
1686       error ("new cannot be applied to a function type");
1687       return error_mark_node;
1688     }
1689
1690   rval = build4 (NEW_EXPR, build_pointer_type (type), placement, type,
1691                  nelts, init);
1692   NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1693   TREE_SIDE_EFFECTS (rval) = 1;
1694   rval = build_new_1 (rval);
1695   if (rval == error_mark_node)
1696     return error_mark_node;
1697
1698   /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain.  */
1699   rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
1700   TREE_NO_WARNING (rval) = 1;
1701
1702   return rval;
1703 }
1704
1705 /* Given a Java class, return a decl for the corresponding java.lang.Class.  */
1706
1707 tree
1708 build_java_class_ref (tree type)
1709 {
1710   tree name = NULL_TREE, class_decl;
1711   static tree CL_suffix = NULL_TREE;
1712   if (CL_suffix == NULL_TREE)
1713     CL_suffix = get_identifier("class$");
1714   if (jclass_node == NULL_TREE)
1715     {
1716       jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
1717       if (jclass_node == NULL_TREE)
1718         fatal_error ("call to Java constructor, while %<jclass%> undefined");
1719
1720       jclass_node = TREE_TYPE (jclass_node);
1721     }
1722
1723   /* Mangle the class$ field.  */
1724   {
1725     tree field;
1726     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1727       if (DECL_NAME (field) == CL_suffix)
1728         {
1729           mangle_decl (field);
1730           name = DECL_ASSEMBLER_NAME (field);
1731           break;
1732         }
1733     if (!field)
1734       internal_error ("can't find class$");
1735     }
1736
1737   class_decl = IDENTIFIER_GLOBAL_VALUE (name);
1738   if (class_decl == NULL_TREE)
1739     {
1740       class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
1741       TREE_STATIC (class_decl) = 1;
1742       DECL_EXTERNAL (class_decl) = 1;
1743       TREE_PUBLIC (class_decl) = 1;
1744       DECL_ARTIFICIAL (class_decl) = 1;
1745       DECL_IGNORED_P (class_decl) = 1;
1746       pushdecl_top_level (class_decl);
1747       make_decl_rtl (class_decl);
1748     }
1749   return class_decl;
1750 }
1751
1752
1753 /* Called from cplus_expand_expr when expanding a NEW_EXPR.  The return
1754    value is immediately handed to expand_expr.  */
1755
1756 static tree
1757 build_new_1 (tree exp)
1758 {
1759   tree placement, init;
1760   tree size, rval;
1761   /* True iff this is a call to "operator new[]" instead of just
1762      "operator new".  */
1763   bool array_p = false;
1764   /* True iff ARRAY_P is true and the bound of the array type is
1765      not necessarily a compile time constant.  For example, VLA_P is
1766      true for "new int[f()]".  */
1767   bool vla_p = false;
1768   /* The type being allocated.  If ARRAY_P is true, this will be an
1769      ARRAY_TYPE.  */
1770   tree full_type;
1771   /* If ARRAY_P is true, the element type of the array.  This is an
1772      never ARRAY_TYPE; for something like "new int[3][4]", the
1773      ELT_TYPE is "int".  If ARRAY_P is false, this is the same type as
1774      FULL_TYPE.  */
1775   tree elt_type;
1776   /* The type of the new-expression.  (This type is always a pointer
1777      type.)  */
1778   tree pointer_type;
1779   /* The type pointed to by POINTER_TYPE.  This type may be different
1780      from ELT_TYPE for a multi-dimensional array; ELT_TYPE is never an
1781      ARRAY_TYPE, but TYPE may be an ARRAY_TYPE.  */
1782   tree type;
1783   /* A pointer type pointing to the FULL_TYPE.  */
1784   tree full_pointer_type;
1785   tree outer_nelts = NULL_TREE;
1786   tree nelts = NULL_TREE;
1787   tree alloc_call, alloc_expr;
1788   /* The address returned by the call to "operator new".  This node is
1789      a VAR_DECL and is therefore reusable.  */
1790   tree alloc_node;
1791   tree alloc_fn;
1792   tree cookie_expr, init_expr;
1793   int nothrow, check_new;
1794   /* Nonzero if the user wrote `::new' rather than just `new'.  */
1795   int globally_qualified_p;
1796   int use_java_new = 0;
1797   /* If non-NULL, the number of extra bytes to allocate at the
1798      beginning of the storage allocated for an array-new expression in
1799      order to store the number of elements.  */
1800   tree cookie_size = NULL_TREE;
1801   /* True if the function we are calling is a placement allocation
1802      function.  */
1803   bool placement_allocation_fn_p;
1804   tree args = NULL_TREE;
1805   /* True if the storage must be initialized, either by a constructor
1806      or due to an explicit new-initializer.  */
1807   bool is_initialized;
1808   /* The address of the thing allocated, not including any cookie.  In
1809      particular, if an array cookie is in use, DATA_ADDR is the
1810      address of the first array element.  This node is a VAR_DECL, and
1811      is therefore reusable.  */
1812   tree data_addr;
1813   tree init_preeval_expr = NULL_TREE;
1814
1815   placement = TREE_OPERAND (exp, 0);
1816   type = TREE_OPERAND (exp, 1);
1817   nelts = TREE_OPERAND (exp, 2);
1818   init = TREE_OPERAND (exp, 3);
1819   globally_qualified_p = NEW_EXPR_USE_GLOBAL (exp);
1820
1821   if (nelts)
1822     {
1823       tree index;
1824
1825       outer_nelts = nelts;
1826       array_p = true;
1827
1828       /* ??? The middle-end will error on us for building a VLA outside a
1829          function context.  Methinks that's not it's purvey.  So we'll do
1830          our own VLA layout later.  */
1831       vla_p = true;
1832       full_type = build_cplus_array_type (type, NULL_TREE);
1833       index = convert (sizetype, nelts);
1834       index = size_binop (MINUS_EXPR, index, size_one_node);
1835       TYPE_DOMAIN (full_type) = build_index_type (index);
1836     }
1837   else
1838     {
1839       full_type = type;
1840       if (TREE_CODE (type) == ARRAY_TYPE)
1841         {
1842           array_p = true;
1843           nelts = array_type_nelts_top (type);
1844           outer_nelts = nelts;
1845           type = TREE_TYPE (type);
1846         }
1847     }
1848
1849   if (!complete_type_or_else (type, exp))
1850     return error_mark_node;
1851
1852   /* If our base type is an array, then make sure we know how many elements
1853      it has.  */
1854   for (elt_type = type;
1855        TREE_CODE (elt_type) == ARRAY_TYPE;
1856        elt_type = TREE_TYPE (elt_type))
1857     nelts = cp_build_binary_op (MULT_EXPR, nelts,
1858                                 array_type_nelts_top (elt_type));
1859
1860   if (TREE_CODE (elt_type) == VOID_TYPE)
1861     {
1862       error ("invalid type %<void%> for new");
1863       return error_mark_node;
1864     }
1865
1866   if (abstract_virtuals_error (NULL_TREE, elt_type))
1867     return error_mark_node;
1868
1869   is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || init);
1870   if (CP_TYPE_CONST_P (elt_type) && !is_initialized)
1871     {
1872       error ("uninitialized const in %<new%> of %q#T", elt_type);
1873       return error_mark_node;
1874     }
1875
1876   size = size_in_bytes (elt_type);
1877   if (array_p)
1878     {
1879       size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1880       if (vla_p)
1881         {
1882           tree n, bitsize;
1883
1884           /* Do our own VLA layout.  Setting TYPE_SIZE/_UNIT is
1885              necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
1886              ...>> to be valid.  */
1887           TYPE_SIZE_UNIT (full_type) = size;
1888           n = convert (bitsizetype, nelts);
1889           bitsize = size_binop (MULT_EXPR, TYPE_SIZE (elt_type), n);
1890           TYPE_SIZE (full_type) = bitsize;
1891         }
1892     }
1893
1894   /* Allocate the object.  */
1895   if (! placement && TYPE_FOR_JAVA (elt_type))
1896     {
1897       tree class_addr, alloc_decl;
1898       tree class_decl = build_java_class_ref (elt_type);
1899       static const char alloc_name[] = "_Jv_AllocObject";
1900
1901       use_java_new = 1;
1902       alloc_decl = NULL;
1903       if (!get_global_value_if_present (get_identifier (alloc_name),
1904                                         &alloc_decl))
1905         {
1906           error ("call to Java constructor with %qs undefined", alloc_name);
1907           return error_mark_node;
1908         }
1909       else if (really_overloaded_fn (alloc_decl))
1910         {
1911           error ("%qD should never be overloaded", alloc_decl);
1912           return error_mark_node;
1913         }
1914       alloc_decl = OVL_CURRENT (alloc_decl);
1915       class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1916       alloc_call = (build_function_call
1917                     (alloc_decl,
1918                      build_tree_list (NULL_TREE, class_addr)));
1919     }
1920   else
1921     {
1922       tree fnname;
1923       tree fns;
1924
1925       fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
1926
1927       if (!globally_qualified_p
1928           && CLASS_TYPE_P (elt_type)
1929           && (array_p
1930               ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
1931               : TYPE_HAS_NEW_OPERATOR (elt_type)))
1932         {
1933           /* Use a class-specific operator new.  */
1934           /* If a cookie is required, add some extra space.  */
1935           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1936             {
1937               cookie_size = targetm.cxx.get_cookie_size (elt_type);
1938               size = size_binop (PLUS_EXPR, size, cookie_size);
1939             }
1940           /* Create the argument list.  */
1941           args = tree_cons (NULL_TREE, size, placement);
1942           /* Do name-lookup to find the appropriate operator.  */
1943           fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
1944           if (fns == NULL_TREE)
1945             {
1946               error ("no suitable %qD found in class %qT", fnname, elt_type);
1947               return error_mark_node;
1948             }
1949           if (TREE_CODE (fns) == TREE_LIST)
1950             {
1951               error ("request for member %qD is ambiguous", fnname);
1952               print_candidates (fns);
1953               return error_mark_node;
1954             }
1955           alloc_call = build_new_method_call (build_dummy_object (elt_type),
1956                                               fns, args,
1957                                               /*conversion_path=*/NULL_TREE,
1958                                               LOOKUP_NORMAL);
1959         }
1960       else
1961         {
1962           /* Use a global operator new.  */
1963           /* See if a cookie might be required.  */
1964           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1965             cookie_size = targetm.cxx.get_cookie_size (elt_type);
1966           else
1967             cookie_size = NULL_TREE;
1968
1969           alloc_call = build_operator_new_call (fnname, placement,
1970                                                 &size, &cookie_size);
1971         }
1972     }
1973
1974   if (alloc_call == error_mark_node)
1975     return error_mark_node;
1976
1977   /* In the simple case, we can stop now.  */
1978   pointer_type = build_pointer_type (type);
1979   if (!cookie_size && !is_initialized)
1980     return build_nop (pointer_type, alloc_call);
1981
1982   /* While we're working, use a pointer to the type we've actually
1983      allocated. Store the result of the call in a variable so that we
1984      can use it more than once.  */
1985   full_pointer_type = build_pointer_type (full_type);
1986   alloc_expr = get_target_expr (build_nop (full_pointer_type, alloc_call));
1987   alloc_node = TARGET_EXPR_SLOT (alloc_expr);
1988
1989   /* Strip any COMPOUND_EXPRs from ALLOC_CALL.  */
1990   while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
1991     alloc_call = TREE_OPERAND (alloc_call, 1);
1992   alloc_fn = get_callee_fndecl (alloc_call);
1993   gcc_assert (alloc_fn != NULL_TREE);
1994
1995   /* Now, check to see if this function is actually a placement
1996      allocation function.  This can happen even when PLACEMENT is NULL
1997      because we might have something like:
1998
1999        struct S { void* operator new (size_t, int i = 0); };
2000
2001      A call to `new S' will get this allocation function, even though
2002      there is no explicit placement argument.  If there is more than
2003      one argument, or there are variable arguments, then this is a
2004      placement allocation function.  */
2005   placement_allocation_fn_p
2006     = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2007        || varargs_function_p (alloc_fn));
2008
2009   /* Preevaluate the placement args so that we don't reevaluate them for a
2010      placement delete.  */
2011   if (placement_allocation_fn_p)
2012     {
2013       tree inits;
2014       stabilize_call (alloc_call, &inits);
2015       if (inits)
2016         alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2017                              alloc_expr);
2018     }
2019
2020   /*        unless an allocation function is declared with an empty  excep-
2021      tion-specification  (_except.spec_),  throw(), it indicates failure to
2022      allocate storage by throwing a bad_alloc exception  (clause  _except_,
2023      _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2024      cation function is declared  with  an  empty  exception-specification,
2025      throw(), it returns null to indicate failure to allocate storage and a
2026      non-null pointer otherwise.
2027
2028      So check for a null exception spec on the op new we just called.  */
2029
2030   nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2031   check_new = (flag_check_new || nothrow) && ! use_java_new;
2032
2033   if (cookie_size)
2034     {
2035       tree cookie;
2036       tree cookie_ptr;
2037
2038       /* Adjust so we're pointing to the start of the object.  */
2039       data_addr = get_target_expr (build2 (PLUS_EXPR, full_pointer_type,
2040                                            alloc_node, cookie_size));
2041
2042       /* Store the number of bytes allocated so that we can know how
2043          many elements to destroy later.  We use the last sizeof
2044          (size_t) bytes to store the number of elements.  */
2045       cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2046                            data_addr, size_in_bytes (sizetype));
2047       cookie = build_indirect_ref (cookie_ptr, NULL);
2048
2049       cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2050
2051       if (targetm.cxx.cookie_has_size ())
2052         {
2053           /* Also store the element size.  */
2054           cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2055                                cookie_ptr, size_in_bytes (sizetype));
2056           cookie = build_indirect_ref (cookie_ptr, NULL);
2057           cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2058                            size_in_bytes(elt_type));
2059           cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2060                                 cookie, cookie_expr);
2061         }
2062       data_addr = TARGET_EXPR_SLOT (data_addr);
2063     }
2064   else
2065     {
2066       cookie_expr = NULL_TREE;
2067       data_addr = alloc_node;
2068     }
2069
2070   /* Now initialize the allocated object.  Note that we preevaluate the
2071      initialization expression, apart from the actual constructor call or
2072      assignment--we do this because we want to delay the allocation as long
2073      as possible in order to minimize the size of the exception region for
2074      placement delete.  */
2075   if (is_initialized)
2076     {
2077       bool stable;
2078
2079       init_expr = build_indirect_ref (data_addr, NULL);
2080
2081       if (array_p)
2082         {
2083           bool explicit_default_init_p = false;
2084
2085           if (init == void_zero_node)
2086             {
2087               init = NULL_TREE;
2088               explicit_default_init_p = true;
2089             }
2090           else if (init)
2091             pedwarn ("ISO C++ forbids initialization in array new");
2092
2093           init_expr
2094             = build_vec_init (init_expr,
2095                               cp_build_binary_op (MINUS_EXPR, outer_nelts,
2096                                                   integer_one_node),
2097                               init,
2098                               explicit_default_init_p,
2099                               /*from_array=*/0);
2100
2101           /* An array initialization is stable because the initialization
2102              of each element is a full-expression, so the temporaries don't
2103              leak out.  */
2104           stable = true;
2105         }
2106       else
2107         {
2108           if (init == void_zero_node)
2109             init = build_default_init (full_type, nelts);
2110
2111           if (TYPE_NEEDS_CONSTRUCTING (type))
2112             {
2113               init_expr = build_special_member_call (init_expr,
2114                                                      complete_ctor_identifier,
2115                                                      init, elt_type,
2116                                                      LOOKUP_NORMAL);
2117               stable = stabilize_init (init_expr, &init_preeval_expr);
2118             }
2119           else
2120             {
2121               /* We are processing something like `new int (10)', which
2122                  means allocate an int, and initialize it with 10.  */
2123
2124               if (TREE_CODE (init) == TREE_LIST)
2125                 init = build_x_compound_expr_from_list (init,
2126                                                         "new initializer");
2127               else
2128                 gcc_assert (TREE_CODE (init) != CONSTRUCTOR
2129                             || TREE_TYPE (init) != NULL_TREE);
2130
2131               init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
2132               stable = stabilize_init (init_expr, &init_preeval_expr);
2133             }
2134         }
2135
2136       if (init_expr == error_mark_node)
2137         return error_mark_node;
2138
2139       /* If any part of the object initialization terminates by throwing an
2140          exception and a suitable deallocation function can be found, the
2141          deallocation function is called to free the memory in which the
2142          object was being constructed, after which the exception continues
2143          to propagate in the context of the new-expression. If no
2144          unambiguous matching deallocation function can be found,
2145          propagating the exception does not cause the object's memory to be
2146          freed.  */
2147       if (flag_exceptions && ! use_java_new)
2148         {
2149           enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2150           tree cleanup;
2151
2152           /* The Standard is unclear here, but the right thing to do
2153              is to use the same method for finding deallocation
2154              functions that we use for finding allocation functions.  */
2155           cleanup = build_op_delete_call (dcode, alloc_node, size,
2156                                           globally_qualified_p,
2157                                           (placement_allocation_fn_p
2158                                            ? alloc_call : NULL_TREE));
2159
2160           if (!cleanup)
2161             /* We're done.  */;
2162           else if (stable)
2163             /* This is much simpler if we were able to preevaluate all of
2164                the arguments to the constructor call.  */
2165             init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2166                                 init_expr, cleanup);
2167           else
2168             /* Ack!  First we allocate the memory.  Then we set our sentry
2169                variable to true, and expand a cleanup that deletes the
2170                memory if sentry is true.  Then we run the constructor, and
2171                finally clear the sentry.
2172
2173                We need to do this because we allocate the space first, so
2174                if there are any temporaries with cleanups in the
2175                constructor args and we weren't able to preevaluate them, we
2176                need this EH region to extend until end of full-expression
2177                to preserve nesting.  */
2178             {
2179               tree end, sentry, begin;
2180
2181               begin = get_target_expr (boolean_true_node);
2182               CLEANUP_EH_ONLY (begin) = 1;
2183
2184               sentry = TARGET_EXPR_SLOT (begin);
2185
2186               TARGET_EXPR_CLEANUP (begin)
2187                 = build3 (COND_EXPR, void_type_node, sentry,
2188                           cleanup, void_zero_node);
2189
2190               end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2191                             sentry, boolean_false_node);
2192
2193               init_expr
2194                 = build2 (COMPOUND_EXPR, void_type_node, begin,
2195                           build2 (COMPOUND_EXPR, void_type_node, init_expr,
2196                                   end));
2197             }
2198
2199         }
2200     }
2201   else
2202     init_expr = NULL_TREE;
2203
2204   /* Now build up the return value in reverse order.  */
2205
2206   rval = data_addr;
2207
2208   if (init_expr)
2209     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2210   if (cookie_expr)
2211     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2212
2213   if (rval == alloc_node)
2214     /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2215        and return the call (which doesn't need to be adjusted).  */
2216     rval = TARGET_EXPR_INITIAL (alloc_expr);
2217   else
2218     {
2219       if (check_new)
2220         {
2221           tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
2222                                            integer_zero_node);
2223           rval = build_conditional_expr (ifexp, rval, alloc_node);
2224         }
2225
2226       /* Perform the allocation before anything else, so that ALLOC_NODE
2227          has been initialized before we start using it.  */
2228       rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2229     }
2230
2231   if (init_preeval_expr)
2232     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2233
2234   /* Convert to the final type.  */
2235   rval = build_nop (pointer_type, rval);
2236
2237   /* A new-expression is never an lvalue.  */
2238   rval = rvalue (rval);
2239
2240   return rval;
2241 }
2242 \f
2243 static tree
2244 build_vec_delete_1 (tree base, tree maxindex, tree type,
2245     special_function_kind auto_delete_vec, int use_global_delete)
2246 {
2247   tree virtual_size;
2248   tree ptype = build_pointer_type (type = complete_type (type));
2249   tree size_exp = size_in_bytes (type);
2250
2251   /* Temporary variables used by the loop.  */
2252   tree tbase, tbase_init;
2253
2254   /* This is the body of the loop that implements the deletion of a
2255      single element, and moves temp variables to next elements.  */
2256   tree body;
2257
2258   /* This is the LOOP_EXPR that governs the deletion of the elements.  */
2259   tree loop = 0;
2260
2261   /* This is the thing that governs what to do after the loop has run.  */
2262   tree deallocate_expr = 0;
2263
2264   /* This is the BIND_EXPR which holds the outermost iterator of the
2265      loop.  It is convenient to set this variable up and test it before
2266      executing any other code in the loop.
2267      This is also the containing expression returned by this function.  */
2268   tree controller = NULL_TREE;
2269
2270   /* We should only have 1-D arrays here.  */
2271   gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2272
2273   if (! IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2274     goto no_destructor;
2275
2276   /* The below is short by the cookie size.  */
2277   virtual_size = size_binop (MULT_EXPR, size_exp,
2278                              convert (sizetype, maxindex));
2279
2280   tbase = create_temporary_var (ptype);
2281   tbase_init = build_modify_expr (tbase, NOP_EXPR,
2282                                   fold_build2 (PLUS_EXPR, ptype,
2283                                                base,
2284                                                virtual_size));
2285   DECL_REGISTER (tbase) = 1;
2286   controller = build3 (BIND_EXPR, void_type_node, tbase,
2287                        NULL_TREE, NULL_TREE);
2288   TREE_SIDE_EFFECTS (controller) = 1;
2289
2290   body = build1 (EXIT_EXPR, void_type_node,
2291                  build2 (EQ_EXPR, boolean_type_node, base, tbase));
2292   body = build_compound_expr
2293     (body, build_modify_expr (tbase, NOP_EXPR,
2294                               build2 (MINUS_EXPR, ptype, tbase, size_exp)));
2295   body = build_compound_expr
2296     (body, build_delete (ptype, tbase, sfk_complete_destructor,
2297                          LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2298
2299   loop = build1 (LOOP_EXPR, void_type_node, body);
2300   loop = build_compound_expr (tbase_init, loop);
2301
2302  no_destructor:
2303   /* If the delete flag is one, or anything else with the low bit set,
2304      delete the storage.  */
2305   if (auto_delete_vec != sfk_base_destructor)
2306     {
2307       tree base_tbd;
2308
2309       /* The below is short by the cookie size.  */
2310       virtual_size = size_binop (MULT_EXPR, size_exp,
2311                                  convert (sizetype, maxindex));
2312
2313       if (! TYPE_VEC_NEW_USES_COOKIE (type))
2314         /* no header */
2315         base_tbd = base;
2316       else
2317         {
2318           tree cookie_size;
2319
2320           cookie_size = targetm.cxx.get_cookie_size (type);
2321           base_tbd
2322             = cp_convert (ptype,
2323                           cp_build_binary_op (MINUS_EXPR,
2324                                               cp_convert (string_type_node,
2325                                                           base),
2326                                               cookie_size));
2327           /* True size with header.  */
2328           virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2329         }
2330
2331       if (auto_delete_vec == sfk_deleting_destructor)
2332         deallocate_expr = build_x_delete (base_tbd,
2333                                           2 | use_global_delete,
2334                                           virtual_size);
2335     }
2336
2337   body = loop;
2338   if (!deallocate_expr)
2339     ;
2340   else if (!body)
2341     body = deallocate_expr;
2342   else
2343     body = build_compound_expr (body, deallocate_expr);
2344
2345   if (!body)
2346     body = integer_zero_node;
2347
2348   /* Outermost wrapper: If pointer is null, punt.  */
2349   body = fold_build3 (COND_EXPR, void_type_node,
2350                       fold_build2 (NE_EXPR, boolean_type_node, base,
2351                                    convert (TREE_TYPE (base),
2352                                             integer_zero_node)),
2353                       body, integer_zero_node);
2354   body = build1 (NOP_EXPR, void_type_node, body);
2355
2356   if (controller)
2357     {
2358       TREE_OPERAND (controller, 1) = body;
2359       body = controller;
2360     }
2361
2362   if (TREE_CODE (base) == SAVE_EXPR)
2363     /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
2364     body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2365
2366   return convert_to_void (body, /*implicit=*/NULL);
2367 }
2368
2369 /* Create an unnamed variable of the indicated TYPE.  */
2370
2371 tree
2372 create_temporary_var (tree type)
2373 {
2374   tree decl;
2375
2376   decl = build_decl (VAR_DECL, NULL_TREE, type);
2377   TREE_USED (decl) = 1;
2378   DECL_ARTIFICIAL (decl) = 1;
2379   DECL_IGNORED_P (decl) = 1;
2380   DECL_SOURCE_LOCATION (decl) = input_location;
2381   DECL_CONTEXT (decl) = current_function_decl;
2382
2383   return decl;
2384 }
2385
2386 /* Create a new temporary variable of the indicated TYPE, initialized
2387    to INIT.
2388
2389    It is not entered into current_binding_level, because that breaks
2390    things when it comes time to do final cleanups (which take place
2391    "outside" the binding contour of the function).  */
2392
2393 static tree
2394 get_temp_regvar (tree type, tree init)
2395 {
2396   tree decl;
2397
2398   decl = create_temporary_var (type);
2399   add_decl_expr (decl);
2400
2401   finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
2402
2403   return decl;
2404 }
2405
2406 /* `build_vec_init' returns tree structure that performs
2407    initialization of a vector of aggregate types.
2408
2409    BASE is a reference to the vector, of ARRAY_TYPE.
2410    MAXINDEX is the maximum index of the array (one less than the
2411      number of elements).  It is only used if
2412      TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2413
2414    INIT is the (possibly NULL) initializer.
2415
2416    If EXPLICIT_DEFAULT_INIT_P is true, then INIT must be NULL.  All
2417    elements in the array are default-initialized.
2418
2419    FROM_ARRAY is 0 if we should init everything with INIT
2420    (i.e., every element initialized from INIT).
2421    FROM_ARRAY is 1 if we should index into INIT in parallel
2422    with initialization of DECL.
2423    FROM_ARRAY is 2 if we should index into INIT in parallel,
2424    but use assignment instead of initialization.  */
2425
2426 tree
2427 build_vec_init (tree base, tree maxindex, tree init,
2428                 bool explicit_default_init_p,
2429                 int from_array)
2430 {
2431   tree rval;
2432   tree base2 = NULL_TREE;
2433   tree size;
2434   tree itype = NULL_TREE;
2435   tree iterator;
2436   /* The type of the array.  */
2437   tree atype = TREE_TYPE (base);
2438   /* The type of an element in the array.  */
2439   tree type = TREE_TYPE (atype);
2440   /* The element type reached after removing all outer array
2441      types.  */
2442   tree inner_elt_type;
2443   /* The type of a pointer to an element in the array.  */
2444   tree ptype;
2445   tree stmt_expr;
2446   tree compound_stmt;
2447   int destroy_temps;
2448   tree try_block = NULL_TREE;
2449   int num_initialized_elts = 0;
2450   bool is_global;
2451
2452   if (TYPE_DOMAIN (atype))
2453     maxindex = array_type_nelts (atype);
2454
2455   if (maxindex == NULL_TREE || maxindex == error_mark_node)
2456     return error_mark_node;
2457
2458   if (explicit_default_init_p)
2459     gcc_assert (!init);
2460
2461   inner_elt_type = strip_array_types (atype);
2462   if (init
2463       && (from_array == 2
2464           ? (!CLASS_TYPE_P (inner_elt_type)
2465              || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
2466           : !TYPE_NEEDS_CONSTRUCTING (type))
2467       && ((TREE_CODE (init) == CONSTRUCTOR
2468            /* Don't do this if the CONSTRUCTOR might contain something
2469               that might throw and require us to clean up.  */
2470            && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
2471                || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2472           || from_array))
2473     {
2474       /* Do non-default initialization of POD arrays resulting from
2475          brace-enclosed initializers.  In this case, digest_init and
2476          store_constructor will handle the semantics for us.  */
2477
2478       stmt_expr = build2 (INIT_EXPR, atype, base, init);
2479       return stmt_expr;
2480     }
2481
2482   maxindex = cp_convert (ptrdiff_type_node, maxindex);
2483   ptype = build_pointer_type (type);
2484   size = size_in_bytes (type);
2485   if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
2486     base = cp_convert (ptype, decay_conversion (base));
2487
2488   /* The code we are generating looks like:
2489      ({
2490        T* t1 = (T*) base;
2491        T* rval = t1;
2492        ptrdiff_t iterator = maxindex;
2493        try {
2494          for (; iterator != -1; --iterator) {
2495            ... initialize *t1 ...
2496            ++t1;
2497          }
2498        } catch (...) {
2499          ... destroy elements that were constructed ...
2500        }
2501        rval;
2502      })
2503
2504      We can omit the try and catch blocks if we know that the
2505      initialization will never throw an exception, or if the array
2506      elements do not have destructors.  We can omit the loop completely if
2507      the elements of the array do not have constructors.
2508
2509      We actually wrap the entire body of the above in a STMT_EXPR, for
2510      tidiness.
2511
2512      When copying from array to another, when the array elements have
2513      only trivial copy constructors, we should use __builtin_memcpy
2514      rather than generating a loop.  That way, we could take advantage
2515      of whatever cleverness the back-end has for dealing with copies
2516      of blocks of memory.  */
2517
2518   is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2519   destroy_temps = stmts_are_full_exprs_p ();
2520   current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2521   rval = get_temp_regvar (ptype, base);
2522   base = get_temp_regvar (ptype, rval);
2523   iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2524
2525   /* Protect the entire array initialization so that we can destroy
2526      the partially constructed array if an exception is thrown.
2527      But don't do this if we're assigning.  */
2528   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2529       && from_array != 2)
2530     {
2531       try_block = begin_try_block ();
2532     }
2533
2534   if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2535     {
2536       /* Do non-default initialization of non-POD arrays resulting from
2537          brace-enclosed initializers.  */
2538       unsigned HOST_WIDE_INT idx;
2539       tree elt;
2540       from_array = 0;
2541
2542       FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
2543         {
2544           tree baseref = build1 (INDIRECT_REF, type, base);
2545
2546           num_initialized_elts++;
2547
2548           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2549           if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
2550             finish_expr_stmt (build_aggr_init (baseref, elt, 0));
2551           else
2552             finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR,
2553                                                  elt));
2554           current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2555
2556           finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2557           finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0));
2558         }
2559
2560       /* Clear out INIT so that we don't get confused below.  */
2561       init = NULL_TREE;
2562     }
2563   else if (from_array)
2564     {
2565       /* If initializing one array from another, initialize element by
2566          element.  We rely upon the below calls the do argument
2567          checking.  */
2568       if (init)
2569         {
2570           base2 = decay_conversion (init);
2571           itype = TREE_TYPE (base2);
2572           base2 = get_temp_regvar (itype, base2);
2573           itype = TREE_TYPE (itype);
2574         }
2575       else if (TYPE_LANG_SPECIFIC (type)
2576                && TYPE_NEEDS_CONSTRUCTING (type)
2577                && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2578         {
2579           error ("initializer ends prematurely");
2580           return error_mark_node;
2581         }
2582     }
2583
2584   /* Now, default-initialize any remaining elements.  We don't need to
2585      do that if a) the type does not need constructing, or b) we've
2586      already initialized all the elements.
2587
2588      We do need to keep going if we're copying an array.  */
2589
2590   if (from_array
2591       || ((TYPE_NEEDS_CONSTRUCTING (type) || explicit_default_init_p)
2592           && ! (host_integerp (maxindex, 0)
2593                 && (num_initialized_elts
2594                     == tree_low_cst (maxindex, 0) + 1))))
2595     {
2596       /* If the ITERATOR is equal to -1, then we don't have to loop;
2597          we've already initialized all the elements.  */
2598       tree for_stmt;
2599       tree elt_init;
2600       tree to;
2601
2602       for_stmt = begin_for_stmt ();
2603       finish_for_init_stmt (for_stmt);
2604       finish_for_cond (build2 (NE_EXPR, boolean_type_node,
2605                                iterator, integer_minus_one_node),
2606                        for_stmt);
2607       finish_for_expr (build_unary_op (PREDECREMENT_EXPR, iterator, 0),
2608                        for_stmt);
2609
2610       to = build1 (INDIRECT_REF, type, base);
2611
2612       if (from_array)
2613         {
2614           tree from;
2615
2616           if (base2)
2617             from = build1 (INDIRECT_REF, itype, base2);
2618           else
2619             from = NULL_TREE;
2620
2621           if (from_array == 2)
2622             elt_init = build_modify_expr (to, NOP_EXPR, from);
2623           else if (TYPE_NEEDS_CONSTRUCTING (type))
2624             elt_init = build_aggr_init (to, from, 0);
2625           else if (from)
2626             elt_init = build_modify_expr (to, NOP_EXPR, from);
2627           else
2628             gcc_unreachable ();
2629         }
2630       else if (TREE_CODE (type) == ARRAY_TYPE)
2631         {
2632           if (init != 0)
2633             sorry
2634               ("cannot initialize multi-dimensional array with initializer");
2635           elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2636                                      0, 0,
2637                                      /*explicit_default_init_p=*/false,
2638                                      0);
2639         }
2640       else if (!TYPE_NEEDS_CONSTRUCTING (type))
2641         elt_init = (build_modify_expr
2642                     (to, INIT_EXPR,
2643                      build_zero_init (type, size_one_node,
2644                                       /*static_storage_p=*/false)));
2645       else
2646         elt_init = build_aggr_init (to, init, 0);
2647
2648       current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2649       finish_expr_stmt (elt_init);
2650       current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2651
2652       finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2653       if (base2)
2654         finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0));
2655
2656       finish_for_stmt (for_stmt);
2657     }
2658
2659   /* Make sure to cleanup any partially constructed elements.  */
2660   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2661       && from_array != 2)
2662     {
2663       tree e;
2664       tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator);
2665
2666       /* Flatten multi-dimensional array since build_vec_delete only
2667          expects one-dimensional array.  */
2668       if (TREE_CODE (type) == ARRAY_TYPE)
2669         m = cp_build_binary_op (MULT_EXPR, m,
2670                                 array_type_nelts_total (type));
2671
2672       finish_cleanup_try_block (try_block);
2673       e = build_vec_delete_1 (rval, m,
2674                               inner_elt_type, sfk_base_destructor,
2675                               /*use_global_delete=*/0);
2676       finish_cleanup (e, try_block);
2677     }
2678
2679   /* The value of the array initialization is the array itself, RVAL
2680      is a pointer to the first element.  */
2681   finish_stmt_expr_expr (rval, stmt_expr);
2682
2683   stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2684
2685   /* Now convert make the result have the correct type.  */
2686   atype = build_pointer_type (atype);
2687   stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2688   stmt_expr = build_indirect_ref (stmt_expr, NULL);
2689
2690   current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2691   return stmt_expr;
2692 }
2693
2694 /* Free up storage of type TYPE, at address ADDR.
2695
2696    TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2697    of pointer.
2698
2699    VIRTUAL_SIZE is the amount of storage that was allocated, and is
2700    used as the second argument to operator delete.  It can include
2701    things like padding and magic size cookies.  It has virtual in it,
2702    because if you have a base pointer and you delete through a virtual
2703    destructor, it should be the size of the dynamic object, not the
2704    static object, see Free Store 12.5 ISO C++.
2705
2706    This does not call any destructors.  */
2707
2708 tree
2709 build_x_delete (tree addr, int which_delete, tree virtual_size)
2710 {
2711   int use_global_delete = which_delete & 1;
2712   int use_vec_delete = !!(which_delete & 2);
2713   enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
2714
2715   return build_op_delete_call (code, addr, virtual_size, use_global_delete,
2716                                NULL_TREE);
2717 }
2718
2719 /* Call the DTOR_KIND destructor for EXP.  FLAGS are as for
2720    build_delete.  */
2721
2722 static tree
2723 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2724 {
2725   tree name;
2726   tree fn;
2727   switch (dtor_kind)
2728     {
2729     case sfk_complete_destructor:
2730       name = complete_dtor_identifier;
2731       break;
2732
2733     case sfk_base_destructor:
2734       name = base_dtor_identifier;
2735       break;
2736
2737     case sfk_deleting_destructor:
2738       name = deleting_dtor_identifier;
2739       break;
2740
2741     default:
2742       gcc_unreachable ();
2743     }
2744   fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2745   return build_new_method_call (exp, fn,
2746                                 /*args=*/NULL_TREE,
2747                                 /*conversion_path=*/NULL_TREE,
2748                                 flags);
2749 }
2750
2751 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2752    ADDR is an expression which yields the store to be destroyed.
2753    AUTO_DELETE is the name of the destructor to call, i.e., either
2754    sfk_complete_destructor, sfk_base_destructor, or
2755    sfk_deleting_destructor.
2756
2757    FLAGS is the logical disjunction of zero or more LOOKUP_
2758    flags.  See cp-tree.h for more info.  */
2759
2760 tree
2761 build_delete (tree type, tree addr, special_function_kind auto_delete,
2762     int flags, int use_global_delete)
2763 {
2764   tree expr;
2765
2766   if (addr == error_mark_node)
2767     return error_mark_node;
2768
2769   /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2770      set to `error_mark_node' before it gets properly cleaned up.  */
2771   if (type == error_mark_node)
2772     return error_mark_node;
2773
2774   type = TYPE_MAIN_VARIANT (type);
2775
2776   if (TREE_CODE (type) == POINTER_TYPE)
2777     {
2778       bool complete_p = true;
2779
2780       type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2781       if (TREE_CODE (type) == ARRAY_TYPE)
2782         goto handle_array;
2783
2784       /* We don't want to warn about delete of void*, only other
2785           incomplete types.  Deleting other incomplete types
2786           invokes undefined behavior, but it is not ill-formed, so
2787           compile to something that would even do The Right Thing
2788           (TM) should the type have a trivial dtor and no delete
2789           operator.  */
2790       if (!VOID_TYPE_P (type))
2791         {
2792           complete_type (type);
2793           if (!COMPLETE_TYPE_P (type))
2794             {
2795               warning (0, "possible problem detected in invocation of "
2796                        "delete operator:");
2797               cxx_incomplete_type_diagnostic (addr, type, 1);
2798               inform ("neither the destructor nor the class-specific "
2799                       "operator delete will be called, even if they are "
2800                       "declared when the class is defined.");
2801               complete_p = false;
2802             }
2803         }
2804       if (VOID_TYPE_P (type) || !complete_p || !IS_AGGR_TYPE (type))
2805         /* Call the builtin operator delete.  */
2806         return build_builtin_delete_call (addr);
2807       if (TREE_SIDE_EFFECTS (addr))
2808         addr = save_expr (addr);
2809
2810       /* Throw away const and volatile on target type of addr.  */
2811       addr = convert_force (build_pointer_type (type), addr, 0);
2812     }
2813   else if (TREE_CODE (type) == ARRAY_TYPE)
2814     {
2815     handle_array:
2816
2817       if (TYPE_DOMAIN (type) == NULL_TREE)
2818         {
2819           error ("unknown array size in delete");
2820           return error_mark_node;
2821         }
2822       return build_vec_delete (addr, array_type_nelts (type),
2823                                auto_delete, use_global_delete);
2824     }
2825   else
2826     {
2827       /* Don't check PROTECT here; leave that decision to the
2828          destructor.  If the destructor is accessible, call it,
2829          else report error.  */
2830       addr = build_unary_op (ADDR_EXPR, addr, 0);
2831       if (TREE_SIDE_EFFECTS (addr))
2832         addr = save_expr (addr);
2833
2834       addr = convert_force (build_pointer_type (type), addr, 0);
2835     }
2836
2837   gcc_assert (IS_AGGR_TYPE (type));
2838
2839   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2840     {
2841       if (auto_delete != sfk_deleting_destructor)
2842         return void_zero_node;
2843
2844       return build_op_delete_call
2845         (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), use_global_delete,
2846          NULL_TREE);
2847     }
2848   else
2849     {
2850       tree do_delete = NULL_TREE;
2851       tree ifexp;
2852
2853       if (CLASSTYPE_LAZY_DESTRUCTOR (type))
2854         lazily_declare_fn (sfk_destructor, type);
2855
2856       /* For `::delete x', we must not use the deleting destructor
2857          since then we would not be sure to get the global `operator
2858          delete'.  */
2859       if (use_global_delete && auto_delete == sfk_deleting_destructor)
2860         {
2861           /* We will use ADDR multiple times so we must save it.  */
2862           addr = save_expr (addr);
2863           /* Delete the object.  */
2864           do_delete = build_builtin_delete_call (addr);
2865           /* Otherwise, treat this like a complete object destructor
2866              call.  */
2867           auto_delete = sfk_complete_destructor;
2868         }
2869       /* If the destructor is non-virtual, there is no deleting
2870          variant.  Instead, we must explicitly call the appropriate
2871          `operator delete' here.  */
2872       else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
2873                && auto_delete == sfk_deleting_destructor)
2874         {
2875           /* We will use ADDR multiple times so we must save it.  */
2876           addr = save_expr (addr);
2877           /* Build the call.  */
2878           do_delete = build_op_delete_call (DELETE_EXPR,
2879                                             addr,
2880                                             cxx_sizeof_nowarn (type),
2881                                             /*global_p=*/false,
2882                                             NULL_TREE);
2883           /* Call the complete object destructor.  */
2884           auto_delete = sfk_complete_destructor;
2885         }
2886       else if (auto_delete == sfk_deleting_destructor
2887                && TYPE_GETS_REG_DELETE (type))
2888         {
2889           /* Make sure we have access to the member op delete, even though
2890              we'll actually be calling it from the destructor.  */
2891           build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
2892                                 /*global_p=*/false, NULL_TREE);
2893         }
2894
2895       expr = build_dtor_call (build_indirect_ref (addr, NULL),
2896                               auto_delete, flags);
2897       if (do_delete)
2898         expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
2899
2900       if (flags & LOOKUP_DESTRUCTOR)
2901         /* Explicit destructor call; don't check for null pointer.  */
2902         ifexp = integer_one_node;
2903       else
2904         /* Handle deleting a null pointer.  */
2905         ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
2906
2907       if (ifexp != integer_one_node)
2908         expr = build3 (COND_EXPR, void_type_node,
2909                        ifexp, expr, void_zero_node);
2910
2911       return expr;
2912     }
2913 }
2914
2915 /* At the beginning of a destructor, push cleanups that will call the
2916    destructors for our base classes and members.
2917
2918    Called from begin_destructor_body.  */
2919
2920 void
2921 push_base_cleanups (void)
2922 {
2923   tree binfo, base_binfo;
2924   int i;
2925   tree member;
2926   tree expr;
2927   VEC(tree,gc) *vbases;
2928
2929   /* Run destructors for all virtual baseclasses.  */
2930   if (CLASSTYPE_VBASECLASSES (current_class_type))
2931     {
2932       tree cond = (condition_conversion
2933                    (build2 (BIT_AND_EXPR, integer_type_node,
2934                             current_in_charge_parm,
2935                             integer_two_node)));
2936
2937       /* The CLASSTYPE_VBASECLASSES vector is in initialization
2938          order, which is also the right order for pushing cleanups.  */
2939       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
2940            VEC_iterate (tree, vbases, i, base_binfo); i++)
2941         {
2942           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
2943             {
2944               expr = build_special_member_call (current_class_ref,
2945                                                 base_dtor_identifier,
2946                                                 NULL_TREE,
2947                                                 base_binfo,
2948                                                 (LOOKUP_NORMAL
2949                                                  | LOOKUP_NONVIRTUAL));
2950               expr = build3 (COND_EXPR, void_type_node, cond,
2951                              expr, void_zero_node);
2952               finish_decl_cleanup (NULL_TREE, expr);
2953             }
2954         }
2955     }
2956
2957   /* Take care of the remaining baseclasses.  */
2958   for (binfo = TYPE_BINFO (current_class_type), i = 0;
2959        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2960     {
2961       if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
2962           || BINFO_VIRTUAL_P (base_binfo))
2963         continue;
2964
2965       expr = build_special_member_call (current_class_ref,
2966                                         base_dtor_identifier,
2967                                         NULL_TREE, base_binfo,
2968                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
2969       finish_decl_cleanup (NULL_TREE, expr);
2970     }
2971
2972   for (member = TYPE_FIELDS (current_class_type); member;
2973        member = TREE_CHAIN (member))
2974     {
2975       if (TREE_CODE (member) != FIELD_DECL || DECL_ARTIFICIAL (member))
2976         continue;
2977       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
2978         {
2979           tree this_member = (build_class_member_access_expr
2980                               (current_class_ref, member,
2981                                /*access_path=*/NULL_TREE,
2982                                /*preserve_reference=*/false));
2983           tree this_type = TREE_TYPE (member);
2984           expr = build_delete (this_type, this_member,
2985                                sfk_complete_destructor,
2986                                LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
2987                                0);
2988           finish_decl_cleanup (NULL_TREE, expr);
2989         }
2990     }
2991 }
2992
2993 /* Build a C++ vector delete expression.
2994    MAXINDEX is the number of elements to be deleted.
2995    ELT_SIZE is the nominal size of each element in the vector.
2996    BASE is the expression that should yield the store to be deleted.
2997    This function expands (or synthesizes) these calls itself.
2998    AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
2999
3000    This also calls delete for virtual baseclasses of elements of the vector.
3001
3002    Update: MAXINDEX is no longer needed.  The size can be extracted from the
3003    start of the vector for pointers, and from the type for arrays.  We still
3004    use MAXINDEX for arrays because it happens to already have one of the
3005    values we'd have to extract.  (We could use MAXINDEX with pointers to
3006    confirm the size, and trap if the numbers differ; not clear that it'd
3007    be worth bothering.)  */
3008
3009 tree
3010 build_vec_delete (tree base, tree maxindex,
3011     special_function_kind auto_delete_vec, int use_global_delete)
3012 {
3013   tree type;
3014   tree rval;
3015   tree base_init = NULL_TREE;
3016
3017   type = TREE_TYPE (base);
3018
3019   if (TREE_CODE (type) == POINTER_TYPE)
3020     {
3021       /* Step back one from start of vector, and read dimension.  */
3022       tree cookie_addr;
3023
3024       if (TREE_SIDE_EFFECTS (base))
3025         {
3026           base_init = get_target_expr (base);
3027           base = TARGET_EXPR_SLOT (base_init);
3028         }
3029       type = strip_array_types (TREE_TYPE (type));
3030       cookie_addr = build2 (MINUS_EXPR,
3031                             build_pointer_type (sizetype),
3032                             base,
3033                             TYPE_SIZE_UNIT (sizetype));
3034       maxindex = build_indirect_ref (cookie_addr, NULL);
3035     }
3036   else if (TREE_CODE (type) == ARRAY_TYPE)
3037     {
3038       /* Get the total number of things in the array, maxindex is a
3039          bad name.  */
3040       maxindex = array_type_nelts_total (type);
3041       type = strip_array_types (type);
3042       base = build_unary_op (ADDR_EXPR, base, 1);
3043       if (TREE_SIDE_EFFECTS (base))
3044         {
3045           base_init = get_target_expr (base);
3046           base = TARGET_EXPR_SLOT (base_init);
3047         }
3048     }
3049   else
3050     {
3051       if (base != error_mark_node)
3052         error ("type to vector delete is neither pointer or array type");
3053       return error_mark_node;
3054     }
3055
3056   rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3057                              use_global_delete);
3058   if (base_init)
3059     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
3060
3061   return rval;
3062 }