gcc/cp/init.c

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