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