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