gcc/cp/init.c

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