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