gcc/cp/init.c

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