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