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