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