contrib/gcc/cp/init.c

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