gcc/cp/init.c

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