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