gcc/cp/init.c

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