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