gcc/cp/init.c

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