gcc/cp/init.c

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