gcc/cp/init.c

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