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