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