contrib/gcc/cp/init.c

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