gcc/cp/init.c

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