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