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