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