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