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