gcc/cp/init.c

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