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_new_op (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 (NEW_EXPR, build_pointer_type (type),
2028                         placement, t, init);
2029       NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
2030       return rval;
2031     }
2032
2033   /* ``A reference cannot be created by the new operator.  A reference
2034      is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2035      returned by new.'' ARM 5.3.3 */
2036   if (TREE_CODE (type) == REFERENCE_TYPE)
2037     {
2038       error ("new cannot be applied to a reference type");
2039       type = TREE_TYPE (type);
2040     }
2041
2042   if (TREE_CODE (type) == FUNCTION_TYPE)
2043     {
2044       error ("new cannot be applied to a function type");
2045       return error_mark_node;
2046     }
2047
2048   /* When the object being created is an array, the new-expression yields a
2049      pointer to the initial element (if any) of the array.  For example,
2050      both new int and new int[10] return an int*.  5.3.4.  */
2051   if (TREE_CODE (type) == ARRAY_TYPE && has_array == 0)
2052     {
2053       nelts = array_type_nelts_top (type);
2054       has_array = 1;
2055       type = TREE_TYPE (type);
2056     }
2057
2058   if (has_array)
2059     t = build_nt (ARRAY_REF, type, nelts);
2060   else
2061     t = type;
2062
2063   rval = build (NEW_EXPR, build_pointer_type (type), placement, t, init);
2064   NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
2065   TREE_SIDE_EFFECTS (rval) = 1;
2066   rval = build_new_1 (rval);
2067   if (rval == error_mark_node)
2068     return error_mark_node;
2069
2070   /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain.  */
2071   rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2072   TREE_NO_UNUSED_WARNING (rval) = 1;
2073
2074   return rval;
2075 }
2076
2077 /* Given a Java class, return a decl for the corresponding java.lang.Class.  */
2078
2079 tree
2080 build_java_class_ref (type)
2081      tree type;
2082 {
2083   tree name = NULL_TREE, class_decl;
2084   static tree CL_suffix = NULL_TREE;
2085   if (CL_suffix == NULL_TREE)
2086     CL_suffix = get_identifier("class$");
2087   if (jclass_node == NULL_TREE)
2088     {
2089       jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2090       if (jclass_node == NULL_TREE)
2091         fatal_error ("call to Java constructor, while `jclass' undefined");
2092
2093       jclass_node = TREE_TYPE (jclass_node);
2094     }
2095
2096   /* Mangle the class$ field */
2097   {
2098     tree field;
2099     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2100       if (DECL_NAME (field) == CL_suffix)
2101         {
2102           mangle_decl (field);
2103           name = DECL_ASSEMBLER_NAME (field);
2104           break;
2105         }
2106     if (!field)
2107       internal_error ("can't find class$");
2108     }
2109
2110   class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2111   if (class_decl == NULL_TREE)
2112     {
2113       class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
2114       TREE_STATIC (class_decl) = 1;
2115       DECL_EXTERNAL (class_decl) = 1;
2116       TREE_PUBLIC (class_decl) = 1;
2117       DECL_ARTIFICIAL (class_decl) = 1;
2118       DECL_IGNORED_P (class_decl) = 1;
2119       pushdecl_top_level (class_decl);
2120       make_decl_rtl (class_decl, NULL);
2121     }
2122   return class_decl;
2123 }
2124
2125 /* Returns the size of the cookie to use when allocating an array
2126    whose elements have the indicated TYPE.  Assumes that it is already
2127    known that a cookie is needed.  */
2128
2129 static tree
2130 get_cookie_size (type)
2131      tree type;
2132 {
2133   tree cookie_size;
2134
2135   /* We need to allocate an additional max (sizeof (size_t), alignof
2136      (true_type)) bytes.  */
2137   tree sizetype_size;
2138   tree type_align;
2139
2140   sizetype_size = size_in_bytes (sizetype);
2141   type_align = size_int (TYPE_ALIGN_UNIT (type));
2142   if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
2143     cookie_size = sizetype_size;
2144   else
2145     cookie_size = type_align;
2146
2147   return cookie_size;
2148 }
2149
2150 /* Called from cplus_expand_expr when expanding a NEW_EXPR.  The return
2151    value is immediately handed to expand_expr.  */
2152
2153 static tree
2154 build_new_1 (exp)
2155      tree exp;
2156 {
2157   tree placement, init;
2158   tree type, true_type, size, rval, t;
2159   tree full_type;
2160   tree outer_nelts = NULL_TREE;
2161   tree nelts = NULL_TREE;
2162   tree alloc_call, alloc_expr, alloc_node;
2163   tree alloc_fn;
2164   tree cookie_expr, init_expr;
2165   int has_array = 0;
2166   enum tree_code code;
2167   int use_cookie, nothrow, check_new;
2168   /* Nonzero if the user wrote `::new' rather than just `new'.  */
2169   int globally_qualified_p;
2170   /* Nonzero if we're going to call a global operator new, rather than
2171      a class-specific version.  */
2172   int use_global_new;
2173   int use_java_new = 0;
2174   /* If non-NULL, the number of extra bytes to allocate at the
2175      beginning of the storage allocated for an array-new expression in
2176      order to store the number of elements.  */
2177   tree cookie_size = NULL_TREE;
2178   /* True if the function we are calling is a placement allocation
2179      function.  */
2180   bool placement_allocation_fn_p;
2181
2182   placement = TREE_OPERAND (exp, 0);
2183   type = TREE_OPERAND (exp, 1);
2184   init = TREE_OPERAND (exp, 2);
2185   globally_qualified_p = NEW_EXPR_USE_GLOBAL (exp);
2186
2187   if (TREE_CODE (type) == ARRAY_REF)
2188     {
2189       has_array = 1;
2190       nelts = outer_nelts = TREE_OPERAND (type, 1);
2191       type = TREE_OPERAND (type, 0);
2192
2193       /* Use an incomplete array type to avoid VLA headaches.  */
2194       full_type = build_cplus_array_type (type, NULL_TREE);
2195     }
2196   else
2197     full_type = type;
2198
2199   true_type = type;
2200
2201   code = has_array ? VEC_NEW_EXPR : NEW_EXPR;
2202
2203   /* If our base type is an array, then make sure we know how many elements
2204      it has.  */
2205   while (TREE_CODE (true_type) == ARRAY_TYPE)
2206     {
2207       tree this_nelts = array_type_nelts_top (true_type);
2208       nelts = cp_build_binary_op (MULT_EXPR, nelts, this_nelts);
2209       true_type = TREE_TYPE (true_type);
2210     }
2211
2212   if (!complete_type_or_else (true_type, exp))
2213     return error_mark_node;
2214
2215   size = size_in_bytes (true_type);
2216   if (has_array)
2217     size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
2218
2219   if (TREE_CODE (true_type) == VOID_TYPE)
2220     {
2221       error ("invalid type `void' for new");
2222       return error_mark_node;
2223     }
2224
2225   if (abstract_virtuals_error (NULL_TREE, true_type))
2226     return error_mark_node;
2227
2228   /* Figure out whether or not we're going to use the global operator
2229      new.  */
2230   if (!globally_qualified_p
2231       && IS_AGGR_TYPE (true_type)
2232       && (has_array
2233           ? TYPE_HAS_ARRAY_NEW_OPERATOR (true_type)
2234           : TYPE_HAS_NEW_OPERATOR (true_type)))
2235     use_global_new = 0;
2236   else
2237     use_global_new = 1;
2238
2239   /* We only need cookies for arrays containing types for which we
2240      need cookies.  */
2241   if (!has_array || !TYPE_VEC_NEW_USES_COOKIE (true_type))
2242     use_cookie = 0;
2243   /* When using placement new, users may not realize that they need
2244      the extra storage.  We require that the operator called be
2245      the global placement operator new[].  */
2246   else if (placement && !TREE_CHAIN (placement)
2247            && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2248                            ptr_type_node))
2249     use_cookie = !use_global_new;
2250   /* Otherwise, we need the cookie.  */
2251   else
2252     use_cookie = 1;
2253
2254   /* Compute the number of extra bytes to allocate, now that we know
2255      whether or not we need the cookie.  */
2256   if (use_cookie)
2257     {
2258       cookie_size = get_cookie_size (true_type);
2259       size = size_binop (PLUS_EXPR, size, cookie_size);
2260     }
2261
2262   /* Allocate the object.  */
2263
2264   if (! placement && TYPE_FOR_JAVA (true_type))
2265     {
2266       tree class_addr, alloc_decl;
2267       tree class_decl = build_java_class_ref (true_type);
2268       tree class_size = size_in_bytes (true_type);
2269       static const char alloc_name[] = "_Jv_AllocObject";
2270       use_java_new = 1;
2271       alloc_decl = IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name));
2272       if (alloc_decl == NULL_TREE)
2273         fatal_error ("call to Java constructor with `%s' undefined",
2274                      alloc_name);
2275
2276       class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2277       alloc_call = (build_function_call
2278                     (alloc_decl,
2279                      tree_cons (NULL_TREE, class_addr,
2280                                 build_tree_list (NULL_TREE, class_size))));
2281     }
2282   else
2283     {
2284       tree fnname;
2285       tree args;
2286
2287       args = tree_cons (NULL_TREE, size, placement);
2288       fnname = ansi_opname (code);
2289
2290       if (use_global_new)
2291         alloc_call = (build_new_function_call
2292                       (lookup_function_nonclass (fnname, args),
2293                        args));
2294       else
2295         alloc_call = build_method_call (build_dummy_object (true_type),
2296                                         fnname, args,
2297                                         TYPE_BINFO (true_type),
2298                                         LOOKUP_NORMAL);
2299     }
2300
2301   if (alloc_call == error_mark_node)
2302     return error_mark_node;
2303
2304   /* The ALLOC_CALL should be a CALL_EXPR -- or a COMPOUND_EXPR whose
2305      right-hand-side is ultimately a CALL_EXPR -- and the first
2306      operand should be the address of a known FUNCTION_DECL.  */
2307   t = alloc_call;
2308   while (TREE_CODE (t) == COMPOUND_EXPR)
2309     t = TREE_OPERAND (t, 1);
2310   alloc_fn = get_callee_fndecl (t);
2311   my_friendly_assert (alloc_fn != NULL_TREE, 20020325);
2312   /* Now, check to see if this function is actually a placement
2313      allocation function.  This can happen even when PLACEMENT is NULL
2314      because we might have something like:
2315
2316        struct S { void* operator new (size_t, int i = 0); };
2317
2318      A call to `new S' will get this allocation function, even though
2319      there is no explicit placement argument.  If there is more than
2320      one argument, or there are variable arguments, then this is a
2321      placement allocation function.  */
2322   placement_allocation_fn_p
2323     = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2324        || varargs_function_p (alloc_fn));
2325
2326   /*        unless an allocation function is declared with an empty  excep-
2327      tion-specification  (_except.spec_),  throw(), it indicates failure to
2328      allocate storage by throwing a bad_alloc exception  (clause  _except_,
2329      _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2330      cation function is declared  with  an  empty  exception-specification,
2331      throw(), it returns null to indicate failure to allocate storage and a
2332      non-null pointer otherwise.
2333
2334      So check for a null exception spec on the op new we just called.  */
2335
2336   nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2337   check_new = (flag_check_new || nothrow) && ! use_java_new;
2338
2339   alloc_expr = alloc_call;
2340
2341   if (use_cookie)
2342     /* Adjust so we're pointing to the start of the object.  */
2343     alloc_expr = build (PLUS_EXPR, TREE_TYPE (alloc_expr),
2344                         alloc_expr, cookie_size);
2345
2346   /* While we're working, use a pointer to the type we've actually
2347      allocated.  */
2348   alloc_expr = convert (build_pointer_type (full_type), alloc_expr);
2349
2350   /* Now save the allocation expression so we only evaluate it once.  */
2351   alloc_expr = get_target_expr (alloc_expr);
2352   alloc_node = TREE_OPERAND (alloc_expr, 0);
2353
2354   /* Now initialize the cookie.  */
2355   if (use_cookie)
2356     {
2357       tree cookie;
2358
2359       /* Store the number of bytes allocated so that we can know how
2360          many elements to destroy later.  We use the last sizeof
2361          (size_t) bytes to store the number of elements.  */
2362       cookie = build (MINUS_EXPR, build_pointer_type (sizetype),
2363                       alloc_node, size_in_bytes (sizetype));
2364       cookie = build_indirect_ref (cookie, NULL);
2365
2366       cookie_expr = build (MODIFY_EXPR, void_type_node, cookie, nelts);
2367       TREE_SIDE_EFFECTS (cookie_expr) = 1;
2368     }
2369   else
2370     cookie_expr = NULL_TREE;
2371
2372   /* Now initialize the allocated object.  */
2373   init_expr = NULL_TREE;
2374   if (TYPE_NEEDS_CONSTRUCTING (type) || init)
2375     {
2376       init_expr = build_indirect_ref (alloc_node, NULL);
2377
2378       if (init == void_zero_node)
2379         init = build_default_init (full_type);
2380       else if (init && pedantic && has_array)
2381         pedwarn ("ISO C++ forbids initialization in array new");
2382
2383       if (has_array)
2384         init_expr
2385           = build_vec_init (init_expr,
2386                             cp_build_binary_op (MINUS_EXPR, outer_nelts,
2387                                                 integer_one_node),
2388                             init, /*from_array=*/0);
2389       else if (TYPE_NEEDS_CONSTRUCTING (type))
2390         init_expr = build_special_member_call (init_expr,
2391                                                complete_ctor_identifier,
2392                                                init, TYPE_BINFO (true_type),
2393                                                LOOKUP_NORMAL);
2394       else
2395         {
2396           /* We are processing something like `new int (10)', which
2397              means allocate an int, and initialize it with 10.  */
2398
2399           if (TREE_CODE (init) == TREE_LIST)
2400             {
2401               if (TREE_CHAIN (init) != NULL_TREE)
2402                 pedwarn
2403                   ("initializer list being treated as compound expression");
2404               init = build_compound_expr (init);
2405             }
2406           else if (TREE_CODE (init) == CONSTRUCTOR
2407                    && TREE_TYPE (init) == NULL_TREE)
2408             {
2409               pedwarn ("ISO C++ forbids aggregate initializer to new");
2410               init = digest_init (type, init, 0);
2411             }
2412
2413           init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
2414         }
2415
2416       if (init_expr == error_mark_node)
2417         return error_mark_node;
2418
2419       /* If any part of the object initialization terminates by throwing an
2420          exception and a suitable deallocation function can be found, the
2421          deallocation function is called to free the memory in which the
2422          object was being constructed, after which the exception continues
2423          to propagate in the context of the new-expression. If no
2424          unambiguous matching deallocation function can be found,
2425          propagating the exception does not cause the object's memory to be
2426          freed.  */
2427       if (flag_exceptions && ! use_java_new)
2428         {
2429           enum tree_code dcode = has_array ? VEC_DELETE_EXPR : DELETE_EXPR;
2430           tree cleanup;
2431           int flags = (LOOKUP_NORMAL
2432                        | (globally_qualified_p * LOOKUP_GLOBAL));
2433           tree delete_node;
2434
2435           if (use_cookie)
2436             /* Subtract the padding back out to get to the pointer returned
2437                from operator new.  */
2438             delete_node = fold (build (MINUS_EXPR, TREE_TYPE (alloc_node),
2439                                        alloc_node, cookie_size));
2440           else
2441             delete_node = alloc_node;
2442
2443           /* The Standard is unclear here, but the right thing to do
2444              is to use the same method for finding deallocation
2445              functions that we use for finding allocation functions.  */
2446           flags |= LOOKUP_SPECULATIVELY;
2447
2448           cleanup = build_op_delete_call (dcode, delete_node, size, flags,
2449                                           (placement_allocation_fn_p
2450                                            ? alloc_call : NULL_TREE));
2451
2452           /* Ack!  First we allocate the memory.  Then we set our sentry
2453              variable to true, and expand a cleanup that deletes the memory
2454              if sentry is true.  Then we run the constructor, and finally
2455              clear the sentry.
2456
2457              It would be nice to be able to handle this without the sentry
2458              variable, perhaps with a TRY_CATCH_EXPR, but this doesn't
2459              work.  We allocate the space first, so if there are any
2460              temporaries with cleanups in the constructor args we need this
2461              EH region to extend until end of full-expression to preserve
2462              nesting.
2463
2464              If the backend had some mechanism so that we could force the
2465              allocation to be expanded after all the other args to the
2466              constructor, that would fix the nesting problem and we could
2467              do away with this complexity.  But that would complicate other
2468              things; in particular, it would make it difficult to bail out
2469              if the allocation function returns null.  Er, no, it wouldn't;
2470              we just don't run the constructor.  The standard says it's
2471              unspecified whether or not the args are evaluated.
2472
2473              FIXME FIXME FIXME inline invisible refs as refs.  That way we
2474              can preevaluate value parameters.  */
2475
2476           if (cleanup)
2477             {
2478               tree end, sentry, begin;
2479
2480               begin = get_target_expr (boolean_true_node);
2481               CLEANUP_EH_ONLY (begin) = 1;
2482
2483               sentry = TARGET_EXPR_SLOT (begin);
2484
2485               TARGET_EXPR_CLEANUP (begin)
2486                 = build (COND_EXPR, void_type_node, sentry,
2487                          cleanup, void_zero_node);
2488
2489               end = build (MODIFY_EXPR, TREE_TYPE (sentry),
2490                            sentry, boolean_false_node);
2491
2492               init_expr
2493                 = build (COMPOUND_EXPR, void_type_node, begin,
2494                          build (COMPOUND_EXPR, void_type_node, init_expr,
2495                                 end));
2496             }
2497         }
2498     }
2499   else if (CP_TYPE_CONST_P (true_type))
2500     error ("uninitialized const in `new' of `%#T'", true_type);
2501
2502   /* Now build up the return value in reverse order.  */
2503
2504   rval = alloc_node;
2505
2506   if (init_expr)
2507     rval = build (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2508   if (cookie_expr)
2509     rval = build (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2510
2511   if (rval == alloc_node)
2512     /* If we didn't modify anything, strip the TARGET_EXPR and return the
2513        (adjusted) call.  */
2514     rval = TREE_OPERAND (alloc_expr, 1);
2515   else
2516     {
2517       if (check_new)
2518         {
2519           tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
2520                                            integer_zero_node);
2521           rval = build_conditional_expr (ifexp, rval, alloc_node);
2522         }
2523
2524       rval = build (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2525     }
2526
2527   /* Now strip the outer ARRAY_TYPE, so we return a pointer to the first
2528      element.  */
2529   rval = convert (build_pointer_type (type), rval);
2530
2531   return rval;
2532 }
2533 \f
2534 static tree
2535 build_vec_delete_1 (base, maxindex, type, auto_delete_vec, use_global_delete)
2536      tree base, maxindex, type;
2537      special_function_kind auto_delete_vec;
2538      int use_global_delete;
2539 {
2540   tree virtual_size;
2541   tree ptype = build_pointer_type (type = complete_type (type));
2542   tree size_exp = size_in_bytes (type);
2543
2544   /* Temporary variables used by the loop.  */
2545   tree tbase, tbase_init;
2546
2547   /* This is the body of the loop that implements the deletion of a
2548      single element, and moves temp variables to next elements.  */
2549   tree body;
2550
2551   /* This is the LOOP_EXPR that governs the deletion of the elements.  */
2552   tree loop;
2553
2554   /* This is the thing that governs what to do after the loop has run.  */
2555   tree deallocate_expr = 0;
2556
2557   /* This is the BIND_EXPR which holds the outermost iterator of the
2558      loop.  It is convenient to set this variable up and test it before
2559      executing any other code in the loop.
2560      This is also the containing expression returned by this function.  */
2561   tree controller = NULL_TREE;
2562
2563   /* We should only have 1-D arrays here.  */
2564   if (TREE_CODE (type) == ARRAY_TYPE)
2565     abort ();
2566
2567   if (! IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2568     {
2569       loop = integer_zero_node;
2570       goto no_destructor;
2571     }
2572
2573   /* The below is short by the cookie size.  */
2574   virtual_size = size_binop (MULT_EXPR, size_exp,
2575                              convert (sizetype, maxindex));
2576
2577   tbase = create_temporary_var (ptype);
2578   tbase_init = build_modify_expr (tbase, NOP_EXPR,
2579                                   fold (build (PLUS_EXPR, ptype,
2580                                                base,
2581                                                virtual_size)));
2582   DECL_REGISTER (tbase) = 1;
2583   controller = build (BIND_EXPR, void_type_node, tbase, NULL_TREE, NULL_TREE);
2584   TREE_SIDE_EFFECTS (controller) = 1;
2585
2586   body = NULL_TREE;
2587
2588   body = tree_cons (NULL_TREE,
2589                     build_delete (ptype, tbase, sfk_complete_destructor,
2590                                   LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1),
2591                     body);
2592
2593   body = tree_cons (NULL_TREE,
2594                     build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)),
2595                     body);
2596
2597   body = tree_cons (NULL_TREE,
2598                     build (EXIT_EXPR, void_type_node,
2599                            build (EQ_EXPR, boolean_type_node, base, tbase)),
2600                     body);
2601
2602   loop = build (LOOP_EXPR, void_type_node, build_compound_expr (body));
2603
2604   loop = tree_cons (NULL_TREE, tbase_init,
2605                     tree_cons (NULL_TREE, loop, NULL_TREE));
2606   loop = build_compound_expr (loop);
2607
2608  no_destructor:
2609   /* If the delete flag is one, or anything else with the low bit set,
2610      delete the storage.  */
2611   deallocate_expr = integer_zero_node;
2612   if (auto_delete_vec != sfk_base_destructor)
2613     {
2614       tree base_tbd;
2615
2616       /* The below is short by the cookie size.  */
2617       virtual_size = size_binop (MULT_EXPR, size_exp,
2618                                  convert (sizetype, maxindex));
2619
2620       if (! TYPE_VEC_NEW_USES_COOKIE (type))
2621         /* no header */
2622         base_tbd = base;
2623       else
2624         {
2625           tree cookie_size;
2626
2627           cookie_size = get_cookie_size (type);
2628           base_tbd
2629             = cp_convert (ptype,
2630                           cp_build_binary_op (MINUS_EXPR,
2631                                               cp_convert (string_type_node,
2632                                                           base),
2633                                               cookie_size));
2634           /* True size with header.  */
2635           virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2636         }
2637
2638       if (auto_delete_vec == sfk_deleting_destructor)
2639         deallocate_expr = build_x_delete (base_tbd,
2640                                           2 | use_global_delete,
2641                                           virtual_size);
2642     }
2643
2644   if (loop && deallocate_expr != integer_zero_node)
2645     {
2646       body = tree_cons (NULL_TREE, loop,
2647                         tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
2648       body = build_compound_expr (body);
2649     }
2650   else
2651     body = loop;
2652
2653   /* Outermost wrapper: If pointer is null, punt.  */
2654   body = fold (build (COND_EXPR, void_type_node,
2655                       fold (build (NE_EXPR, boolean_type_node, base,
2656                                    integer_zero_node)),
2657                       body, integer_zero_node));
2658   body = build1 (NOP_EXPR, void_type_node, body);
2659
2660   if (controller)
2661     {
2662       TREE_OPERAND (controller, 1) = body;
2663       body = controller;
2664     }
2665
2666   if (TREE_CODE (base) == SAVE_EXPR)
2667     /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
2668     body = build (COMPOUND_EXPR, void_type_node, base, body);
2669
2670   return cp_convert (void_type_node, body);
2671 }
2672
2673 /* Create an unnamed variable of the indicated TYPE.  */
2674
2675 tree
2676 create_temporary_var (type)
2677      tree type;
2678 {
2679   tree decl;
2680
2681   decl = build_decl (VAR_DECL, NULL_TREE, type);
2682   TREE_USED (decl) = 1;
2683   DECL_ARTIFICIAL (decl) = 1;
2684   DECL_SOURCE_FILE (decl) = input_filename;
2685   DECL_SOURCE_LINE (decl) = lineno;
2686   DECL_IGNORED_P (decl) = 1;
2687   DECL_CONTEXT (decl) = current_function_decl;
2688
2689   return decl;
2690 }
2691
2692 /* Create a new temporary variable of the indicated TYPE, initialized
2693    to INIT.
2694
2695    It is not entered into current_binding_level, because that breaks
2696    things when it comes time to do final cleanups (which take place
2697    "outside" the binding contour of the function).  */
2698
2699 static tree
2700 get_temp_regvar (type, init)
2701      tree type, init;
2702 {
2703   tree decl;
2704
2705   decl = create_temporary_var (type);
2706   if (building_stmt_tree ())
2707     add_decl_stmt (decl);
2708   else
2709     SET_DECL_RTL (decl, assign_temp (type, 2, 0, 1));
2710   finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
2711
2712   return decl;
2713 }
2714
2715 /* `build_vec_init' returns tree structure that performs
2716    initialization of a vector of aggregate types.
2717
2718    BASE is a reference to the vector, of ARRAY_TYPE.
2719    MAXINDEX is the maximum index of the array (one less than the
2720      number of elements).  It is only used if
2721      TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2722    INIT is the (possibly NULL) initializer.
2723
2724    FROM_ARRAY is 0 if we should init everything with INIT
2725    (i.e., every element initialized from INIT).
2726    FROM_ARRAY is 1 if we should index into INIT in parallel
2727    with initialization of DECL.
2728    FROM_ARRAY is 2 if we should index into INIT in parallel,
2729    but use assignment instead of initialization.  */
2730
2731 tree
2732 build_vec_init (base, maxindex, init, from_array)
2733      tree base, init, maxindex;
2734      int from_array;
2735 {
2736   tree rval;
2737   tree base2 = NULL_TREE;
2738   tree size;
2739   tree itype = NULL_TREE;
2740   tree iterator;
2741   /* The type of the array.  */
2742   tree atype = TREE_TYPE (base);
2743   /* The type of an element in the array.  */
2744   tree type = TREE_TYPE (atype);
2745   /* The type of a pointer to an element in the array.  */
2746   tree ptype;
2747   tree stmt_expr;
2748   tree compound_stmt;
2749   int destroy_temps;
2750   tree try_block = NULL_TREE;
2751   tree try_body = NULL_TREE;
2752   int num_initialized_elts = 0;
2753
2754   if (TYPE_DOMAIN (atype))
2755     maxindex = array_type_nelts (atype);
2756
2757   if (maxindex == NULL_TREE || maxindex == error_mark_node)
2758     return error_mark_node;
2759
2760   if (init
2761       && (from_array == 2
2762           ? (!CLASS_TYPE_P (type) || !TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2763           : !TYPE_NEEDS_CONSTRUCTING (type))
2764       && ((TREE_CODE (init) == CONSTRUCTOR
2765            /* Don't do this if the CONSTRUCTOR might contain something
2766               that might throw and require us to clean up.  */
2767            && (CONSTRUCTOR_ELTS (init) == NULL_TREE
2768                || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (target_type (type))))
2769           || from_array))
2770     {
2771       /* Do non-default initialization of POD arrays resulting from
2772          brace-enclosed initializers.  In this case, digest_init and
2773          store_constructor will handle the semantics for us.  */
2774
2775       stmt_expr = build (INIT_EXPR, atype, base, init);
2776       return stmt_expr;
2777     }
2778
2779   maxindex = cp_convert (ptrdiff_type_node, maxindex);
2780   ptype = build_pointer_type (type);
2781   size = size_in_bytes (type);
2782   if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
2783     base = cp_convert (ptype, default_conversion (base));
2784
2785   /* The code we are generating looks like:
2786
2787        T* t1 = (T*) base;
2788        T* rval = t1;
2789        ptrdiff_t iterator = maxindex;
2790        try {
2791          for (; iterator != -1; --iterator) {
2792            ... initialize *t1 ...
2793            ++t1;
2794          }
2795        } catch (...) {
2796          ... destroy elements that were constructed ...
2797        }
2798        return rval;
2799
2800      We can omit the try and catch blocks if we know that the
2801      initialization will never throw an exception, or if the array
2802      elements do not have destructors.  We can omit the loop completely if
2803      the elements of the array do not have constructors.
2804
2805      We actually wrap the entire body of the above in a STMT_EXPR, for
2806      tidiness.
2807
2808      When copying from array to another, when the array elements have
2809      only trivial copy constructors, we should use __builtin_memcpy
2810      rather than generating a loop.  That way, we could take advantage
2811      of whatever cleverness the back-end has for dealing with copies
2812      of blocks of memory.  */
2813
2814   begin_init_stmts (&stmt_expr, &compound_stmt);
2815   destroy_temps = stmts_are_full_exprs_p ();
2816   current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2817   rval = get_temp_regvar (ptype, base);
2818   base = get_temp_regvar (ptype, rval);
2819   iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2820
2821   /* Protect the entire array initialization so that we can destroy
2822      the partially constructed array if an exception is thrown.
2823      But don't do this if we're assigning.  */
2824   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2825       && from_array != 2)
2826     {
2827       try_block = begin_try_block ();
2828       try_body = begin_compound_stmt (/*has_no_scope=*/1);
2829     }
2830
2831   if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2832     {
2833       /* Do non-default initialization of non-POD arrays resulting from
2834          brace-enclosed initializers.  */
2835
2836       tree elts;
2837       from_array = 0;
2838
2839       for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
2840         {
2841           tree elt = TREE_VALUE (elts);
2842           tree baseref = build1 (INDIRECT_REF, type, base);
2843
2844           num_initialized_elts++;
2845
2846           if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
2847             finish_expr_stmt (build_aggr_init (baseref, elt, 0));
2848           else
2849             finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR,
2850                                                  elt));
2851
2852           finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2853           finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0));
2854         }
2855
2856       /* Clear out INIT so that we don't get confused below.  */
2857       init = NULL_TREE;
2858     }
2859   else if (from_array)
2860     {
2861       /* If initializing one array from another, initialize element by
2862          element.  We rely upon the below calls the do argument
2863          checking.  */
2864       if (init)
2865         {
2866           base2 = default_conversion (init);
2867           itype = TREE_TYPE (base2);
2868           base2 = get_temp_regvar (itype, base2);
2869           itype = TREE_TYPE (itype);
2870         }
2871       else if (TYPE_LANG_SPECIFIC (type)
2872                && TYPE_NEEDS_CONSTRUCTING (type)
2873                && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2874         {
2875           error ("initializer ends prematurely");
2876           return error_mark_node;
2877         }
2878     }
2879
2880   /* Now, default-initialize any remaining elements.  We don't need to
2881      do that if a) the type does not need constructing, or b) we've
2882      already initialized all the elements.
2883
2884      We do need to keep going if we're copying an array.  */
2885
2886   if (from_array
2887       || (TYPE_NEEDS_CONSTRUCTING (type)
2888           && ! (host_integerp (maxindex, 0)
2889                 && (num_initialized_elts
2890                     == tree_low_cst (maxindex, 0) + 1))))
2891     {
2892       /* If the ITERATOR is equal to -1, then we don't have to loop;
2893          we've already initialized all the elements.  */
2894       tree for_stmt;
2895       tree for_body;
2896       tree elt_init;
2897
2898       for_stmt = begin_for_stmt ();
2899       finish_for_init_stmt (for_stmt);
2900       finish_for_cond (build (NE_EXPR, boolean_type_node,
2901                               iterator, integer_minus_one_node),
2902                        for_stmt);
2903       finish_for_expr (build_unary_op (PREDECREMENT_EXPR, iterator, 0),
2904                        for_stmt);
2905
2906       /* Otherwise, loop through the elements.  */
2907       for_body = begin_compound_stmt (/*has_no_scope=*/1);
2908
2909       /* When we're not building a statement-tree, things are a little
2910          complicated.  If, when we recursively call build_aggr_init,
2911          an expression containing a TARGET_EXPR is expanded, then it
2912          may get a cleanup.  Then, the result of that expression is
2913          passed to finish_expr_stmt, which will call
2914          expand_start_target_temps/expand_end_target_temps.  However,
2915          the latter call will not cause the cleanup to run because
2916          that block will still be on the block stack.  So, we call
2917          expand_start_target_temps here manually; the corresponding
2918          call to expand_end_target_temps below will cause the cleanup
2919          to be performed.  */
2920       if (!building_stmt_tree ())
2921         expand_start_target_temps ();
2922
2923       if (from_array)
2924         {
2925           tree to = build1 (INDIRECT_REF, type, base);
2926           tree from;
2927
2928           if (base2)
2929             from = build1 (INDIRECT_REF, itype, base2);
2930           else
2931             from = NULL_TREE;
2932
2933           if (from_array == 2)
2934             elt_init = build_modify_expr (to, NOP_EXPR, from);
2935           else if (TYPE_NEEDS_CONSTRUCTING (type))
2936             elt_init = build_aggr_init (to, from, 0);
2937           else if (from)
2938             elt_init = build_modify_expr (to, NOP_EXPR, from);
2939           else
2940             abort ();
2941         }
2942       else if (TREE_CODE (type) == ARRAY_TYPE)
2943         {
2944           if (init != 0)
2945             sorry
2946               ("cannot initialize multi-dimensional array with initializer");
2947           elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2948                                      0, 0, 0);
2949         }
2950       else
2951         elt_init = build_aggr_init (build1 (INDIRECT_REF, type, base),
2952                                     init, 0);
2953
2954       /* The initialization of each array element is a
2955          full-expression, as per core issue 124.  */
2956       if (!building_stmt_tree ())
2957         {
2958           genrtl_expr_stmt (elt_init);
2959           expand_end_target_temps ();
2960         }
2961       else
2962         {
2963           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2964           finish_expr_stmt (elt_init);
2965           current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2966         }
2967
2968       finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2969       if (base2)
2970         finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0));
2971
2972       finish_compound_stmt (/*has_no_scope=*/1, for_body);
2973       finish_for_stmt (for_stmt);
2974     }
2975
2976   /* Make sure to cleanup any partially constructed elements.  */
2977   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2978       && from_array != 2)
2979     {
2980       tree e;
2981       tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator);
2982
2983       /* Flatten multi-dimensional array since build_vec_delete only
2984          expects one-dimensional array.  */
2985       if (TREE_CODE (type) == ARRAY_TYPE)
2986         {
2987           m = cp_build_binary_op (MULT_EXPR, m,
2988                                   array_type_nelts_total (type));
2989           type = strip_array_types (type);
2990         }
2991
2992       finish_compound_stmt (/*has_no_scope=*/1, try_body);
2993       finish_cleanup_try_block (try_block);
2994       e = build_vec_delete_1 (rval, m,
2995                               type,
2996                               sfk_base_destructor,
2997                               /*use_global_delete=*/0);
2998       finish_cleanup (e, try_block);
2999     }
3000
3001   /* The value of the array initialization is the address of the
3002      first element in the array.  */
3003   finish_expr_stmt (rval);
3004
3005   stmt_expr = finish_init_stmts (stmt_expr, compound_stmt);
3006   current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
3007   return stmt_expr;
3008 }
3009
3010 /* Free up storage of type TYPE, at address ADDR.
3011
3012    TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3013    of pointer.
3014
3015    VIRTUAL_SIZE is the amount of storage that was allocated, and is
3016    used as the second argument to operator delete.  It can include
3017    things like padding and magic size cookies.  It has virtual in it,
3018    because if you have a base pointer and you delete through a virtual
3019    destructor, it should be the size of the dynamic object, not the
3020    static object, see Free Store 12.5 ISO C++.
3021
3022    This does not call any destructors.  */
3023
3024 tree
3025 build_x_delete (addr, which_delete, virtual_size)
3026      tree addr;
3027      int which_delete;
3028      tree virtual_size;
3029 {
3030   int use_global_delete = which_delete & 1;
3031   int use_vec_delete = !!(which_delete & 2);
3032   enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
3033   int flags = LOOKUP_NORMAL | (use_global_delete * LOOKUP_GLOBAL);
3034
3035   return build_op_delete_call (code, addr, virtual_size, flags, NULL_TREE);
3036 }
3037
3038 /* Call the DTOR_KIND destructor for EXP.  FLAGS are as for
3039    build_delete.  */
3040
3041 static tree
3042 build_dtor_call (exp, dtor_kind, flags)
3043      tree exp;
3044      special_function_kind dtor_kind;
3045      int flags;
3046 {
3047   tree name;
3048
3049   switch (dtor_kind)
3050     {
3051     case sfk_complete_destructor:
3052       name = complete_dtor_identifier;
3053       break;
3054
3055     case sfk_base_destructor:
3056       name = base_dtor_identifier;
3057       break;
3058
3059     case sfk_deleting_destructor:
3060       name = deleting_dtor_identifier;
3061       break;
3062
3063     default:
3064       abort ();
3065     }
3066   return build_method_call (exp, name, NULL_TREE,
3067                             TYPE_BINFO (TREE_TYPE (exp)), flags);
3068 }
3069
3070 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3071    ADDR is an expression which yields the store to be destroyed.
3072    AUTO_DELETE is the name of the destructor to call, i.e., either
3073    sfk_complete_destructor, sfk_base_destructor, or
3074    sfk_deleting_destructor.
3075
3076    FLAGS is the logical disjunction of zero or more LOOKUP_
3077    flags.  See cp-tree.h for more info.  */
3078
3079 tree
3080 build_delete (type, addr, auto_delete, flags, use_global_delete)
3081      tree type, addr;
3082      special_function_kind auto_delete;
3083      int flags;
3084      int use_global_delete;
3085 {
3086   tree expr;
3087
3088   if (addr == error_mark_node)
3089     return error_mark_node;
3090
3091   /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3092      set to `error_mark_node' before it gets properly cleaned up.  */
3093   if (type == error_mark_node)
3094     return error_mark_node;
3095
3096   type = TYPE_MAIN_VARIANT (type);
3097
3098   if (TREE_CODE (type) == POINTER_TYPE)
3099     {
3100       type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3101       if (TREE_CODE (type) == ARRAY_TYPE)
3102         goto handle_array;
3103
3104       if (VOID_TYPE_P (type)
3105           /* We don't want to warn about delete of void*, only other
3106              incomplete types.  Deleting other incomplete types
3107              invokes undefined behavior, but it is not ill-formed, so
3108              compile to something that would even do The Right Thing
3109              (TM) should the type have a trivial dtor and no delete
3110              operator.  */
3111           || !complete_type_or_diagnostic (type, addr, 1)
3112           || !IS_AGGR_TYPE (type))
3113         {
3114           /* Call the builtin operator delete.  */
3115           return build_builtin_delete_call (addr);
3116         }
3117       if (TREE_SIDE_EFFECTS (addr))
3118         addr = save_expr (addr);
3119
3120       /* throw away const and volatile on target type of addr */
3121       addr = convert_force (build_pointer_type (type), addr, 0);
3122     }
3123   else if (TREE_CODE (type) == ARRAY_TYPE)
3124     {
3125     handle_array:
3126
3127       if (TYPE_DOMAIN (type) == NULL_TREE)
3128         {
3129           error ("unknown array size in delete");
3130           return error_mark_node;
3131         }
3132       return build_vec_delete (addr, array_type_nelts (type),
3133                                auto_delete, use_global_delete);
3134     }
3135   else
3136     {
3137       /* Don't check PROTECT here; leave that decision to the
3138          destructor.  If the destructor is accessible, call it,
3139          else report error.  */
3140       addr = build_unary_op (ADDR_EXPR, addr, 0);
3141       if (TREE_SIDE_EFFECTS (addr))
3142         addr = save_expr (addr);
3143
3144       addr = convert_force (build_pointer_type (type), addr, 0);
3145     }
3146
3147   my_friendly_assert (IS_AGGR_TYPE (type), 220);
3148
3149   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3150     {
3151       if (auto_delete != sfk_deleting_destructor)
3152         return void_zero_node;
3153
3154       return build_op_delete_call
3155         (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3156          LOOKUP_NORMAL | (use_global_delete * LOOKUP_GLOBAL),
3157          NULL_TREE);
3158     }
3159   else
3160     {
3161       tree do_delete = NULL_TREE;
3162       tree ifexp;
3163
3164       my_friendly_assert (TYPE_HAS_DESTRUCTOR (type), 20011213);
3165
3166       /* For `::delete x', we must not use the deleting destructor
3167          since then we would not be sure to get the global `operator
3168          delete'.  */
3169       if (use_global_delete && auto_delete == sfk_deleting_destructor)
3170         {
3171           /* We will use ADDR multiple times so we must save it.  */
3172           addr = save_expr (addr);
3173           /* Delete the object.  */
3174           do_delete = build_builtin_delete_call (addr);
3175           /* Otherwise, treat this like a complete object destructor
3176              call.  */
3177           auto_delete = sfk_complete_destructor;
3178         }
3179       /* If the destructor is non-virtual, there is no deleting
3180          variant.  Instead, we must explicitly call the appropriate
3181          `operator delete' here.  */
3182       else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3183                && auto_delete == sfk_deleting_destructor)
3184         {
3185           /* We will use ADDR multiple times so we must save it.  */
3186           addr = save_expr (addr);
3187           /* Build the call.  */
3188           do_delete = build_op_delete_call (DELETE_EXPR,
3189                                             addr,
3190                                             cxx_sizeof_nowarn (type),
3191                                             LOOKUP_NORMAL,
3192                                             NULL_TREE);
3193           /* Call the complete object destructor.  */
3194           auto_delete = sfk_complete_destructor;
3195         }
3196       else if (auto_delete == sfk_deleting_destructor
3197                && TYPE_GETS_REG_DELETE (type))
3198         {
3199           /* Make sure we have access to the member op delete, even though
3200              we'll actually be calling it from the destructor.  */
3201           build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3202                                 LOOKUP_NORMAL, NULL_TREE);
3203         }
3204
3205       expr = build_dtor_call (build_indirect_ref (addr, NULL),
3206                               auto_delete, flags);
3207       if (do_delete)
3208         expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete);
3209
3210       if (flags & LOOKUP_DESTRUCTOR)
3211         /* Explicit destructor call; don't check for null pointer.  */
3212         ifexp = integer_one_node;
3213       else
3214         /* Handle deleting a null pointer.  */
3215         ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
3216
3217       if (ifexp != integer_one_node)
3218         expr = build (COND_EXPR, void_type_node,
3219                       ifexp, expr, void_zero_node);
3220
3221       return expr;
3222     }
3223 }
3224
3225 /* At the beginning of a destructor, push cleanups that will call the
3226    destructors for our base classes and members.
3227
3228    Called from begin_destructor_body.  */
3229
3230 void
3231 push_base_cleanups ()
3232 {
3233   tree binfos;
3234   int i, n_baseclasses;
3235   tree member;
3236   tree expr;
3237
3238   /* Run destructors for all virtual baseclasses.  */
3239   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
3240     {
3241       tree vbases;
3242       tree cond = (condition_conversion
3243                    (build (BIT_AND_EXPR, integer_type_node,
3244                            current_in_charge_parm,
3245                            integer_two_node)));
3246
3247       vbases = CLASSTYPE_VBASECLASSES (current_class_type);
3248       /* The CLASSTYPE_VBASECLASSES list is in initialization
3249          order, which is also the right order for pushing cleanups.  */
3250       for (; vbases;
3251            vbases = TREE_CHAIN (vbases))
3252         {
3253           tree vbase = TREE_VALUE (vbases);
3254           tree base_type = BINFO_TYPE (vbase);
3255
3256           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
3257             {
3258               expr = build_special_member_call (current_class_ref,
3259                                                 base_dtor_identifier,
3260                                                 NULL_TREE,
3261                                                 vbase,
3262                                                 (LOOKUP_NORMAL
3263                                                  | LOOKUP_NONVIRTUAL));
3264               expr = build (COND_EXPR, void_type_node, cond,
3265                             expr, void_zero_node);
3266               finish_decl_cleanup (NULL_TREE, expr);
3267             }
3268         }
3269     }
3270
3271   binfos = BINFO_BASETYPES (TYPE_BINFO (current_class_type));
3272   n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
3273
3274   /* Take care of the remaining baseclasses.  */
3275   for (i = 0; i < n_baseclasses; i++)
3276     {
3277       tree base_binfo = TREE_VEC_ELT (binfos, i);
3278       if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3279           || TREE_VIA_VIRTUAL (base_binfo))
3280         continue;
3281
3282       expr = build_special_member_call (current_class_ref,
3283                                         base_dtor_identifier,
3284                                         NULL_TREE, base_binfo,
3285                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
3286       finish_decl_cleanup (NULL_TREE, expr);
3287     }
3288
3289   for (member = TYPE_FIELDS (current_class_type); member;
3290        member = TREE_CHAIN (member))
3291     {
3292       if (TREE_CODE (member) != FIELD_DECL || DECL_ARTIFICIAL (member))
3293         continue;
3294       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
3295         {
3296           tree this_member = (build_class_member_access_expr
3297                               (current_class_ref, member,
3298                                /*access_path=*/NULL_TREE,
3299                                /*preserve_reference=*/false));
3300           tree this_type = TREE_TYPE (member);
3301           expr = build_delete (this_type, this_member,
3302                                sfk_complete_destructor,
3303                                LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3304                                0);
3305           finish_decl_cleanup (NULL_TREE, expr);
3306         }
3307     }
3308 }
3309
3310 /* For type TYPE, delete the virtual baseclass objects of DECL.  */
3311
3312 tree
3313 build_vbase_delete (type, decl)
3314      tree type, decl;
3315 {
3316   tree vbases = CLASSTYPE_VBASECLASSES (type);
3317   tree result = NULL_TREE;
3318   tree addr = build_unary_op (ADDR_EXPR, decl, 0);
3319
3320   my_friendly_assert (addr != error_mark_node, 222);
3321
3322   while (vbases)
3323     {
3324       tree this_addr
3325         = convert_force (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases))),
3326                          addr, 0);
3327       result = tree_cons (NULL_TREE,
3328                           build_delete (TREE_TYPE (this_addr), this_addr,
3329                                         sfk_base_destructor,
3330                                         LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0),
3331                           result);
3332       vbases = TREE_CHAIN (vbases);
3333     }
3334   return build_compound_expr (nreverse (result));
3335 }
3336
3337 /* Build a C++ vector delete expression.
3338    MAXINDEX is the number of elements to be deleted.
3339    ELT_SIZE is the nominal size of each element in the vector.
3340    BASE is the expression that should yield the store to be deleted.
3341    This function expands (or synthesizes) these calls itself.
3342    AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3343
3344    This also calls delete for virtual baseclasses of elements of the vector.
3345
3346    Update: MAXINDEX is no longer needed.  The size can be extracted from the
3347    start of the vector for pointers, and from the type for arrays.  We still
3348    use MAXINDEX for arrays because it happens to already have one of the
3349    values we'd have to extract.  (We could use MAXINDEX with pointers to
3350    confirm the size, and trap if the numbers differ; not clear that it'd
3351    be worth bothering.)  */
3352
3353 tree
3354 build_vec_delete (base, maxindex, auto_delete_vec, use_global_delete)
3355      tree base, maxindex;
3356      special_function_kind auto_delete_vec;
3357      int use_global_delete;
3358 {
3359   tree type;
3360
3361   if (TREE_CODE (base) == OFFSET_REF)
3362     base = resolve_offset_ref (base);
3363
3364   type = TREE_TYPE (base);
3365
3366   base = stabilize_reference (base);
3367
3368   if (TREE_CODE (type) == POINTER_TYPE)
3369     {
3370       /* Step back one from start of vector, and read dimension.  */
3371       tree cookie_addr;
3372
3373       if (TREE_SIDE_EFFECTS (base))
3374         base = save_expr (base);
3375       type = strip_array_types (TREE_TYPE (type));
3376       cookie_addr = build (MINUS_EXPR,
3377                            build_pointer_type (sizetype),
3378                            base,
3379                            TYPE_SIZE_UNIT (sizetype));
3380       maxindex = build_indirect_ref (cookie_addr, NULL);
3381     }
3382   else if (TREE_CODE (type) == ARRAY_TYPE)
3383     {
3384       /* get the total number of things in the array, maxindex is a bad name */
3385       maxindex = array_type_nelts_total (type);
3386       type = strip_array_types (type);
3387       base = build_unary_op (ADDR_EXPR, base, 1);
3388       if (TREE_SIDE_EFFECTS (base))
3389         base = save_expr (base);
3390     }
3391   else
3392     {
3393       if (base != error_mark_node)
3394         error ("type to vector delete is neither pointer or array type");
3395       return error_mark_node;
3396     }
3397
3398   return build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3399                              use_global_delete);
3400 }