gcc/cp/init.c

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