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