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