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