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