gcc/cp/init.c

   1 /* Handle initialization things in C++.
   2    Copyright (C) 1987, 89, 92, 93, 94, 1995 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21
  22 /* High-level class interface. */
  23
  24 #include "config.h"
  25 #include "tree.h"
  26 #include "rtl.h"
  27 #include "cp-tree.h"
  28 #include "flags.h"
  29
  30 #undef NULL
  31 #define NULL 0
  32
  33 /* In C++, structures with well-defined constructors are initialized by
  34    those constructors, unasked.  CURRENT_BASE_INIT_LIST
  35    holds a list of stmts for a BASE_INIT term in the grammar.
  36    This list has one element for each base class which must be
  37    initialized.  The list elements are [basename, init], with
  38    type basetype.  This allows the possibly anachronistic form
  39    (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)"
  40    where each successive term can be handed down the constructor
  41    line.  Perhaps this was not intended.  */
  42 tree current_base_init_list, current_member_init_list;
  43
  44 void emit_base_init ();
  45 void check_base_init ();
  46 static void expand_aggr_vbase_init ();
  47 void expand_member_init ();
  48 void expand_aggr_init ();
  49
  50 static void expand_aggr_init_1 ();
  51 static void expand_recursive_init_1 ();
  52 static void expand_recursive_init ();
  53 static void expand_virtual_init PROTO((tree, tree));
  54 tree expand_vec_init ();
  55
  56 static void add_friend (), add_friends ();
  57
  58 /* Cache _builtin_new and _builtin_delete exprs.  */
  59 static tree BIN, BID, BIVN, BIVD;
  60
  61 /* Cache the identifier nodes for the two magic field of a new cookie.  */
  62 static tree nc_nelts_field_id;
  63 #if 0
  64 static tree nc_ptr_2comp_field_id;
  65 #endif
  66
  67 static tree minus_one;
  68
  69 /* Set up local variable for this file.  MUST BE CALLED AFTER
  70    INIT_DECL_PROCESSING.  */
  71
  72 tree BI_header_type, BI_header_size;
  73
  74 void init_init_processing ()
  75 {
  76   tree fields[1];
  77
  78   /* Define implicit `operator new' and `operator delete' functions.  */
  79   BIN = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) NEW_EXPR])));
  80   TREE_USED (TREE_OPERAND (BIN, 0)) = 0;
  81   BID = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) DELETE_EXPR])));
  82   TREE_USED (TREE_OPERAND (BID, 0)) = 0;
  83   BIVN = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) VEC_NEW_EXPR])));
  84   TREE_USED (TREE_OPERAND (BIVN, 0)) = 0;
  85   BIVD = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) VEC_DELETE_EXPR])));
  86   TREE_USED (TREE_OPERAND (BIVD, 0)) = 0;
  87   minus_one = build_int_2 (-1, -1);
  88
  89   /* Define the structure that holds header information for
  90      arrays allocated via operator new.  */
  91   BI_header_type = make_lang_type (RECORD_TYPE);
  92   nc_nelts_field_id = get_identifier ("nelts");
  93   fields[0] = build_lang_field_decl (FIELD_DECL, nc_nelts_field_id, sizetype);
  94   finish_builtin_type (BI_header_type, "__new_cookie", fields,
  95                        0, double_type_node);
  96   BI_header_size = size_in_bytes (BI_header_type);
  97 }
  98
  99 /* Subroutine of emit_base_init.  For BINFO, initialize all the
 100    virtual function table pointers, except those that come from
 101    virtual base classes.  Initialize binfo's vtable pointer, if
 102    INIT_SELF is true.  CAN_ELIDE is true when we know that all virtual
 103    function table pointers in all bases have been initialized already,
 104    probably because their constructors have just be run.  ADDR is the
 105    pointer to the object whos vtables we are going to initialize.
 106
 107    REAL_BINFO is usually the same as BINFO, except when addr is not of
 108    pointer to the type of the real derived type that we want to
 109    initialize for.  This is the case when addr is a pointer to a sub
 110    object of a complete object, and we only want to do part of the
 111    complete object's initiailzation of vtable pointers.  This is done
 112    for all virtual table pointers in virtual base classes.  REAL_BINFO
 113    is used to find the BINFO_VTABLE that we initialize with.  BINFO is
 114    used for conversions of addr to subobjects.
 115
 116    BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo).
 117
 118    Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE
 119    (addr))).  */
 120 void
 121 expand_direct_vtbls_init (real_binfo, binfo, init_self, can_elide, addr)
 122      tree real_binfo, binfo, addr;
 123      int init_self, can_elide;
 124 {
 125   tree real_binfos = BINFO_BASETYPES (real_binfo);
 126   tree binfos = BINFO_BASETYPES (binfo);
 127   int i, n_baselinks = real_binfos ? TREE_VEC_LENGTH (real_binfos) : 0;
 128   int has_expanded = 0;
 129
 130   for (i = 0; i < n_baselinks; i++)
 131     {
 132       tree real_base_binfo = TREE_VEC_ELT (real_binfos, i);
 133       tree base_binfo = TREE_VEC_ELT (binfos, i);
 134       int is_not_base_vtable =
 135         i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo));
 136       if (! TREE_VIA_VIRTUAL (real_base_binfo))
 137         {
 138           expand_direct_vtbls_init (real_base_binfo, base_binfo,
 139                   (is_not_base_vtable || flag_rtti), can_elide, addr);
 140           if (is_not_base_vtable && flag_rtti)
 141             has_expanded = 1;
 142         }
 143     }
 144 #if 0
 145   /* Before turning this on, make sure it is correct.  */
 146   if (can_elide  && ! BINFO_MODIFIED (binfo))
 147     return;
 148 #endif
 149   /* Should we use something besides CLASSTYPE_VFIELDS? */
 150   if (init_self && !has_expanded && CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo)))
 151     {
 152       tree base_ptr = convert_pointer_to_real (binfo, addr);
 153       expand_virtual_init (real_binfo, base_ptr);
 154     }
 155 }
 156 \f
 157 /* 348 - 351 */
 158 /* Subroutine of emit_base_init.  */
 159 static void
 160 perform_member_init (member, name, init, explicit, protect_list)
 161      tree member, name, init, *protect_list;
 162      int explicit;
 163 {
 164   tree decl;
 165   tree type = TREE_TYPE (member);
 166
 167   if (TYPE_NEEDS_CONSTRUCTING (type)
 168       || (init && TYPE_HAS_CONSTRUCTOR (type)))
 169     {
 170       /* Since `init' is already a TREE_LIST on the current_member_init_list,
 171          only build it into one if we aren't already a list.  */
 172       if (init != NULL_TREE && TREE_CODE (init) != TREE_LIST)
 173         init = build_tree_list (NULL_TREE, init);
 174
 175       decl = build_component_ref (C_C_D, name, 0, explicit);
 176
 177       if (explicit
 178           && TREE_CODE (type) == ARRAY_TYPE
 179           && init != NULL_TREE
 180           && TREE_CHAIN (init) == NULL_TREE
 181           && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
 182         {
 183           /* Initialization of one array from another.  */
 184           expand_vec_init (TREE_OPERAND (decl, 1), decl,
 185                            array_type_nelts (type), TREE_VALUE (init), 1);
 186         }
 187       else
 188         expand_aggr_init (decl, init, 0, 0);
 189     }
 190   else
 191     {
 192       if (init == NULL_TREE)
 193         {
 194           if (explicit)
 195             {
 196               cp_error ("incomplete initializer for member `%D' of class `%T' which has no constructor",
 197                         member, current_class_type);
 198               init = error_mark_node;
 199             }
 200           /* member traversal: note it leaves init NULL */
 201           else if (TREE_CODE (TREE_TYPE (member)) == REFERENCE_TYPE)
 202             cp_pedwarn ("uninitialized reference member `%D'", member);
 203         }
 204       else if (TREE_CODE (init) == TREE_LIST)
 205         {
 206           /* There was an explicit member initialization.  Do some
 207              work in that case.  */
 208           if (TREE_CHAIN (init))
 209             {
 210               warning ("initializer list treated as compound expression");
 211               init = build_compound_expr (init);
 212             }
 213           else
 214             init = TREE_VALUE (init);
 215         }
 216
 217       /* We only build this with a null init if we got it from the
 218          current_member_init_list.  */
 219       if (init || explicit)
 220         {
 221           decl = build_component_ref (C_C_D, name, 0, explicit);
 222           expand_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
 223         }
 224     }
 225   expand_cleanups_to (NULL_TREE);
 226
 227   if (TYPE_NEEDS_DESTRUCTOR (type))
 228     {
 229       tree expr = build_component_ref (C_C_D, name, 0, explicit);
 230       expr = build_delete (type, expr, integer_zero_node,
 231                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
 232
 233       if (expr != error_mark_node)
 234         {
 235           start_protect ();
 236           *protect_list = tree_cons (NULL_TREE, expr, *protect_list);
 237         }
 238     }
 239 }
 240
 241 extern int warn_reorder;
 242
 243 /* Subroutine of emit_member_init.  */
 244 static tree
 245 sort_member_init (t)
 246      tree t;
 247 {
 248   tree x, member, name, field, init;
 249   tree init_list = NULL_TREE;
 250   tree fields_to_unmark = NULL_TREE;
 251   int last_pos = 0;
 252   tree last_field;
 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 0
 272           field = (TREE_CODE (name) == COMPONENT_REF
 273                    ? TREE_OPERAND (name, 1) : IDENTIFIER_CLASS_VALUE (name));
 274 #else
 275           /* Let's find out when this happens.  */
 276           my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 348);
 277           field = IDENTIFIER_CLASS_VALUE (name);
 278 #endif
 279
 280           /* If one member shadows another, get the outermost one.  */
 281           if (TREE_CODE (field) == TREE_LIST)
 282             field = TREE_VALUE (field);
 283
 284           if (field == member)
 285             {
 286               if (warn_reorder)
 287                 {
 288                   if (pos < last_pos)
 289                     {
 290                       cp_warning_at ("member initializers for `%#D'", last_field);
 291                       cp_warning_at ("  and `%#D'", field);
 292                       warning ("  will be re-ordered to match declaration order");
 293                     }
 294                   last_pos = pos;
 295                   last_field = field;
 296                 }
 297
 298               /* Make sure we won't try to work on this init again.  */
 299               TREE_PURPOSE (x) = NULL_TREE;
 300               x = build_tree_list (name, TREE_VALUE (x));
 301               goto got_it;
 302             }
 303         }
 304
 305       /* If we didn't find MEMBER in the list, create a dummy entry
 306          so the two lists (INIT_LIST and the list of members) will be
 307          symmetrical.  */
 308       x = build_tree_list (NULL_TREE, NULL_TREE);
 309     got_it:
 310       init_list = chainon (init_list, x);
 311     }
 312
 313   /* Initializers for base members go at the end.  */
 314   for (x = current_member_init_list ; x ; x = TREE_CHAIN (x))
 315     {
 316       name = TREE_PURPOSE (x);
 317       if (name)
 318         {
 319           if (purpose_member (name, init_list))
 320             {
 321               cp_error ("multiple initializations given for member `%D'",
 322                         IDENTIFIER_CLASS_VALUE (name));
 323               continue;
 324             }
 325
 326           init_list = chainon (init_list,
 327                                build_tree_list (name, TREE_VALUE (x)));
 328           TREE_PURPOSE (x) = NULL_TREE;
 329         }
 330     }
 331
 332   return init_list;
 333 }
 334
 335 static void
 336 sort_base_init (t, rbase_ptr, vbase_ptr)
 337      tree t, *rbase_ptr, *vbase_ptr;
 338 {
 339   tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
 340   int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 341
 342   int i;
 343   tree x;
 344   tree last;
 345
 346   /* For warn_reorder.  */
 347   int last_pos = 0;
 348   tree last_base = NULL_TREE;
 349
 350   tree rbases = NULL_TREE;
 351   tree vbases = NULL_TREE;
 352
 353   /* First walk through and splice out vbase and invalid initializers.
 354      Also replace names with binfos.  */
 355
 356   last = tree_cons (NULL_TREE, NULL_TREE, current_base_init_list);
 357   for (x = TREE_CHAIN (last); x; x = TREE_CHAIN (x))
 358     {
 359       tree basename = TREE_PURPOSE (x);
 360       tree binfo;
 361
 362       if (basename == NULL_TREE)
 363         {
 364           /* Initializer for single base class.  Must not
 365              use multiple inheritance or this is ambiguous.  */
 366           switch (n_baseclasses)
 367             {
 368             case 0:
 369               cp_error ("`%T' does not have a base class to initialize",
 370                         current_class_type);
 371               return;
 372             case 1:
 373               break;
 374             default:
 375               cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
 376                         current_class_type);
 377               return;
 378             }
 379           binfo = TREE_VEC_ELT (binfos, 0);
 380         }
 381       else if (is_aggr_typedef (basename, 1))
 382         {
 383           binfo = binfo_or_else (IDENTIFIER_TYPE_VALUE (basename), t);
 384           if (binfo == NULL_TREE)
 385             continue;
 386
 387           /* Virtual base classes are special cases.  Their initializers
 388              are recorded with this constructor, and they are used when
 389              this constructor is the top-level constructor called.  */
 390           if (TREE_VIA_VIRTUAL (binfo))
 391             {
 392               tree v = CLASSTYPE_VBASECLASSES (t);
 393               while (BINFO_TYPE (v) != BINFO_TYPE (binfo))
 394                 v = TREE_CHAIN (v);
 395
 396               vbases = tree_cons (v, TREE_VALUE (x), vbases);
 397               continue;
 398             }
 399           else
 400             {
 401               /* Otherwise, if it is not an immediate base class, complain.  */
 402               for (i = n_baseclasses-1; i >= 0; i--)
 403                 if (BINFO_TYPE (binfo) == BINFO_TYPE (TREE_VEC_ELT (binfos, i)))
 404                   break;
 405               if (i < 0)
 406                 {
 407                   cp_error ("`%T' is not an immediate base class of `%T'",
 408                             IDENTIFIER_TYPE_VALUE (basename),
 409                             current_class_type);
 410                   continue;
 411                 }
 412             }
 413         }
 414       else
 415         my_friendly_abort (365);
 416
 417       TREE_PURPOSE (x) = binfo;
 418       TREE_CHAIN (last) = x;
 419       last = x;
 420     }
 421   TREE_CHAIN (last) = NULL_TREE;
 422
 423   /* Now walk through our regular bases and make sure they're initialized.  */
 424
 425   for (i = 0; i < n_baseclasses; ++i)
 426     {
 427       tree base_binfo = TREE_VEC_ELT (binfos, i);
 428       int pos;
 429
 430       if (TREE_VIA_VIRTUAL (base_binfo))
 431         continue;
 432
 433       for (x = current_base_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
 434         {
 435           tree binfo = TREE_PURPOSE (x);
 436
 437           if (binfo == NULL_TREE)
 438             continue;
 439
 440           if (binfo == base_binfo)
 441             {
 442               if (warn_reorder)
 443                 {
 444                   if (pos < last_pos)
 445                     {
 446                       cp_warning_at ("base initializers for `%#T'", last_base);
 447                       cp_warning_at ("  and `%#T'", BINFO_TYPE (binfo));
 448                       warning ("  will be re-ordered to match inheritance order");
 449                     }
 450                   last_pos = pos;
 451                   last_base = BINFO_TYPE (binfo);
 452                 }
 453
 454               /* Make sure we won't try to work on this init again.  */
 455               TREE_PURPOSE (x) = NULL_TREE;
 456               x = build_tree_list (binfo, TREE_VALUE (x));
 457               goto got_it;
 458             }
 459         }
 460
 461       /* If we didn't find BASE_BINFO in the list, create a dummy entry
 462          so the two lists (RBASES and the list of bases) will be
 463          symmetrical.  */
 464       x = build_tree_list (NULL_TREE, NULL_TREE);
 465     got_it:
 466       rbases = chainon (rbases, x);
 467     }
 468
 469   *rbase_ptr = rbases;
 470   *vbase_ptr = vbases;
 471 }
 472
 473 /* Perform partial cleanups for a base for exception handling.  */
 474 static tree
 475 build_partial_cleanup_for (binfo)
 476      tree binfo;
 477 {
 478   tree expr = convert_pointer_to_real (binfo,
 479                                        build_unary_op (ADDR_EXPR, C_C_D, 0));
 480
 481   return build_delete (TREE_TYPE (expr),
 482                        expr,
 483                        integer_zero_node,
 484                        LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
 485 }
 486
 487 /* Perform whatever initializations have yet to be done on the base
 488    class of the class variable.  These actions are in the global
 489    variable CURRENT_BASE_INIT_LIST.  Such an action could be
 490    NULL_TREE, meaning that the user has explicitly called the base
 491    class constructor with no arguments.
 492
 493    If there is a need for a call to a constructor, we must surround
 494    that call with a pushlevel/poplevel pair, since we are technically
 495    at the PARM level of scope.
 496
 497    Argument IMMEDIATELY, if zero, forces a new sequence to be
 498    generated to contain these new insns, so it can be emitted later.
 499    This sequence is saved in the global variable BASE_INIT_INSNS.
 500    Otherwise, the insns are emitted into the current sequence.
 501
 502    Note that emit_base_init does *not* initialize virtual base
 503    classes.  That is done specially, elsewhere.  */
 504
 505 void
 506 emit_base_init (t, immediately)
 507      tree t;
 508      int immediately;
 509 {
 510   extern tree in_charge_identifier;
 511
 512   tree member, x;
 513   tree mem_init_list;
 514   tree rbase_init_list, vbase_init_list;
 515   tree t_binfo = TYPE_BINFO (t);
 516   tree binfos = BINFO_BASETYPES (t_binfo);
 517   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 518
 519   my_friendly_assert (protect_list == NULL_TREE, 999);
 520
 521   if (! immediately)
 522     {
 523       do_pending_stack_adjust ();
 524       start_sequence ();
 525     }
 526
 527   if (write_symbols == NO_DEBUG)
 528     /* As a matter of principle, `start_sequence' should do this.  */
 529     emit_note (0, -1);
 530   else
 531     /* Always emit a line number note so we can step into constructors.  */
 532     emit_line_note_force (DECL_SOURCE_FILE (current_function_decl),
 533                           DECL_SOURCE_LINE (current_function_decl));
 534
 535   mem_init_list = sort_member_init (t);
 536   current_member_init_list = NULL_TREE;
 537
 538   sort_base_init (t, &rbase_init_list, &vbase_init_list);
 539   current_base_init_list = NULL_TREE;
 540
 541   if (TYPE_USES_VIRTUAL_BASECLASSES (t))
 542     {
 543       tree first_arg = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
 544
 545       expand_start_cond (first_arg, 0);
 546       expand_aggr_vbase_init (t_binfo, C_C_D, current_class_decl,
 547                               vbase_init_list);
 548       expand_end_cond ();
 549     }
 550
 551   /* Now, perform initialization of non-virtual base classes.  */
 552   for (i = 0; i < n_baseclasses; i++)
 553     {
 554       tree base = current_class_decl;
 555       tree base_binfo = TREE_VEC_ELT (binfos, i);
 556       tree init = void_list_node;
 557
 558       if (TREE_VIA_VIRTUAL (base_binfo))
 559         continue;
 560
 561 #if 0 /* Once unsharing happens soon enough.  */
 562       my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo) == t_binfo);
 563 #else
 564       BINFO_INHERITANCE_CHAIN (base_binfo) = t_binfo;
 565 #endif
 566
 567       if (TREE_PURPOSE (rbase_init_list))
 568         init = TREE_VALUE (rbase_init_list);
 569       else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo)))
 570         init = NULL_TREE;
 571
 572       if (init != void_list_node)
 573         {
 574           member = convert_pointer_to (base_binfo, current_class_decl);
 575           expand_aggr_init_1 (base_binfo, 0,
 576                               build_indirect_ref (member, NULL_PTR), init,
 577                               BINFO_OFFSET_ZEROP (base_binfo), LOOKUP_NORMAL);
 578           expand_cleanups_to (NULL_TREE);
 579         }
 580
 581       if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
 582         {
 583           start_protect ();
 584           protect_list = tree_cons (NULL_TREE,
 585                                     build_partial_cleanup_for (base_binfo),
 586                                     protect_list);
 587         }
 588
 589       rbase_init_list = TREE_CHAIN (rbase_init_list);
 590     }
 591
 592   /* Initialize all the virtual function table fields that
 593      do come from virtual base classes. */
 594   if (TYPE_USES_VIRTUAL_BASECLASSES (t))
 595     expand_indirect_vtbls_init (t_binfo, C_C_D, current_class_decl, 0);
 596
 597   /* Initialize all the virtual function table fields that
 598      do not come from virtual base classes.  */
 599   expand_direct_vtbls_init (t_binfo, t_binfo, 1, 1, current_class_decl);
 600
 601   for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
 602     {
 603       tree init, name;
 604       int from_init_list;
 605
 606       /* member could be, for example, a CONST_DECL for an enumerated
 607          tag; we don't want to try to initialize that, since it already
 608          has a value.  */
 609       if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
 610         continue;
 611
 612       /* See if we had a user-specified member initialization.  */
 613       if (TREE_PURPOSE (mem_init_list))
 614         {
 615           name = TREE_PURPOSE (mem_init_list);
 616           init = TREE_VALUE (mem_init_list);
 617           from_init_list = 1;
 618
 619           /* Also see if it's ever a COMPONENT_REF here.  If it is, we
 620              need to do `expand_assignment (name, init, 0, 0);' and
 621              a continue.  */
 622           my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 349);
 623         }
 624       else
 625         {
 626           name = DECL_NAME (member);
 627           init = DECL_INITIAL (member);
 628
 629           from_init_list = 0;
 630         }
 631
 632       perform_member_init (member, name, init, from_init_list, &protect_list);
 633       mem_init_list = TREE_CHAIN (mem_init_list);
 634     }
 635
 636   /* Now initialize any members from our bases.  */
 637   while (mem_init_list)
 638     {
 639       tree name, init, field;
 640
 641       if (TREE_PURPOSE (mem_init_list))
 642         {
 643           name = TREE_PURPOSE (mem_init_list);
 644           init = TREE_VALUE (mem_init_list);
 645           /* XXX: this may need the COMPONENT_REF operand 0 check if
 646              it turns out we actually get them.  */
 647           field = IDENTIFIER_CLASS_VALUE (name);
 648
 649           /* If one member shadows another, get the outermost one.  */
 650           if (TREE_CODE (field) == TREE_LIST)
 651             {
 652               field = TREE_VALUE (field);
 653               if (decl_type_context (field) != current_class_type)
 654                 cp_error ("field `%D' not in immediate context", field);
 655             }
 656
 657 #if 0
 658           /* It turns out if you have an anonymous union in the
 659              class, a member from it can end up not being on the
 660              list of fields (rather, the type is), and therefore
 661              won't be seen by the for loop above.  */
 662
 663           /* The code in this for loop is derived from a general loop
 664              which had this check in it.  Theoretically, we've hit
 665              every initialization for the list of members in T, so
 666              we shouldn't have anything but these left in this list.  */
 667           my_friendly_assert (DECL_FIELD_CONTEXT (field) != t, 351);
 668 #endif
 669
 670           perform_member_init (field, name, init, 1, &protect_list);
 671         }
 672       mem_init_list = TREE_CHAIN (mem_init_list);
 673     }
 674
 675   if (! immediately)
 676     {
 677       extern rtx base_init_insns;
 678
 679       do_pending_stack_adjust ();
 680       my_friendly_assert (base_init_insns == 0, 207);
 681       base_init_insns = get_insns ();
 682       end_sequence ();
 683     }
 684
 685   /* All the implicit try blocks we built up will be zapped
 686      when we come to a real binding contour boundary.  */
 687 }
 688
 689 /* Check that all fields are properly initialized after
 690    an assignment to `this'.  */
 691 void
 692 check_base_init (t)
 693      tree t;
 694 {
 695   tree member;
 696   for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
 697     if (DECL_NAME (member) && TREE_USED (member))
 698       cp_error ("field `%D' used before initialized (after assignment to `this')",
 699                 member);
 700 }
 701
 702 /* This code sets up the virtual function tables appropriate for
 703    the pointer DECL.  It is a one-ply initialization.
 704
 705    BINFO is the exact type that DECL is supposed to be.  In
 706    multiple inheritance, this might mean "C's A" if C : A, B.  */
 707 static void
 708 expand_virtual_init (binfo, decl)
 709      tree binfo, decl;
 710 {
 711   tree type = BINFO_TYPE (binfo);
 712   tree vtbl, vtbl_ptr;
 713   tree vtype, vtype_binfo;
 714
 715   /* This code is crusty.  Should be simple, like:
 716      vtbl = BINFO_VTABLE (binfo);
 717      */
 718   vtype = DECL_CONTEXT (CLASSTYPE_VFIELD (type));
 719   vtype_binfo = get_binfo (vtype, TREE_TYPE (TREE_TYPE (decl)), 0);
 720   vtbl = BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type)), binfo));
 721   assemble_external (vtbl);
 722   TREE_USED (vtbl) = 1;
 723   vtbl = build1 (ADDR_EXPR, TYPE_POINTER_TO (TREE_TYPE (vtbl)), vtbl);
 724   decl = convert_pointer_to_real (vtype_binfo, decl);
 725   vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL_PTR), vtype);
 726   if (vtbl_ptr == error_mark_node)
 727     return;
 728
 729   /* Have to convert VTBL since array sizes may be different.  */
 730   vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
 731   expand_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
 732 }
 733
 734 /* Subroutine of `expand_aggr_vbase_init'.
 735    BINFO is the binfo of the type that is being initialized.
 736    INIT_LIST is the list of initializers for the virtual baseclass.  */
 737 static void
 738 expand_aggr_vbase_init_1 (binfo, exp, addr, init_list)
 739      tree binfo, exp, addr, init_list;
 740 {
 741   tree init = purpose_member (binfo, init_list);
 742   tree ref = build_indirect_ref (addr, NULL_PTR);
 743   if (init)
 744     init = TREE_VALUE (init);
 745   /* Call constructors, but don't set up vtables.  */
 746   expand_aggr_init_1 (binfo, exp, ref, init, 0, LOOKUP_COMPLAIN);
 747   expand_cleanups_to (NULL_TREE);
 748 }
 749
 750 /* Initialize this object's virtual base class pointers.  This must be
 751    done only at the top-level of the object being constructed.
 752
 753    INIT_LIST is list of initialization for constructor to perform.  */
 754 static void
 755 expand_aggr_vbase_init (binfo, exp, addr, init_list)
 756      tree binfo;
 757      tree exp;
 758      tree addr;
 759      tree init_list;
 760 {
 761   tree type = BINFO_TYPE (binfo);
 762
 763   if (TYPE_USES_VIRTUAL_BASECLASSES (type))
 764     {
 765       tree result = init_vbase_pointers (type, addr);
 766       tree vbases;
 767
 768       if (result)
 769         expand_expr_stmt (build_compound_expr (result));
 770
 771       for (vbases = CLASSTYPE_VBASECLASSES (type); vbases;
 772            vbases = TREE_CHAIN (vbases))
 773         {
 774           tree tmp = purpose_member (vbases, result);
 775           expand_aggr_vbase_init_1 (vbases, exp,
 776                                     TREE_OPERAND (TREE_VALUE (tmp), 0),
 777                                     init_list);
 778         }
 779     }
 780 }
 781
 782 /* Subroutine to perform parser actions for member initialization.
 783    S_ID is the scoped identifier.
 784    NAME is the name of the member.
 785    INIT is the initializer, or `void_type_node' if none.  */
 786 void
 787 do_member_init (s_id, name, init)
 788      tree s_id, name, init;
 789 {
 790   tree binfo, base;
 791
 792   if (current_class_type == NULL_TREE
 793       || ! is_aggr_typedef (s_id, 1))
 794     return;
 795   binfo = get_binfo (IDENTIFIER_TYPE_VALUE (s_id),
 796                           current_class_type, 1);
 797   if (binfo == error_mark_node)
 798     return;
 799   if (binfo == 0)
 800     {
 801       error_not_base_type (IDENTIFIER_TYPE_VALUE (s_id), current_class_type);
 802       return;
 803     }
 804
 805   base = convert_pointer_to (binfo, current_class_decl);
 806   expand_member_init (build_indirect_ref (base, NULL_PTR), name, init);
 807 }
 808
 809 /* Function to give error message if member initialization specification
 810    is erroneous.  FIELD is the member we decided to initialize.
 811    TYPE is the type for which the initialization is being performed.
 812    FIELD must be a member of TYPE, or the base type from which FIELD
 813    comes must not need a constructor.
 814
 815    MEMBER_NAME is the name of the member.  */
 816
 817 static int
 818 member_init_ok_or_else (field, type, member_name)
 819      tree field;
 820      tree type;
 821      char *member_name;
 822 {
 823   if (field == error_mark_node)
 824     return 0;
 825   if (field == NULL_TREE)
 826     {
 827       cp_error ("class `%T' does not have any field named `%s'", type,
 828                 member_name);
 829       return 0;
 830     }
 831   if (DECL_CONTEXT (field) != type
 832       && TYPE_NEEDS_CONSTRUCTING (DECL_CONTEXT (field)))
 833     {
 834       cp_error ("member `%D' comes from base class needing constructor",
 835                 field);
 836       return 0;
 837     }
 838   if (TREE_STATIC (field))
 839     {
 840       cp_error ("field `%#D' is static; only point of initialization is its declaration",
 841                 field);
 842       return 0;
 843     }
 844
 845   return 1;
 846 }
 847
 848 /* If NAME is a viable field name for the aggregate DECL,
 849    and PARMS is a viable parameter list, then expand an _EXPR
 850    which describes this initialization.
 851
 852    Note that we do not need to chase through the class's base classes
 853    to look for NAME, because if it's in that list, it will be handled
 854    by the constructor for that base class.
 855
 856    We do not yet have a fixed-point finder to instantiate types
 857    being fed to overloaded constructors.  If there is a unique
 858    constructor, then argument types can be got from that one.
 859
 860    If INIT is non-NULL, then it the initialization should
 861    be placed in `current_base_init_list', where it will be processed
 862    by `emit_base_init'.  */
 863 void
 864 expand_member_init (exp, name, init)
 865      tree exp, name, init;
 866 {
 867   extern tree ptr_type_node;    /* should be in tree.h */
 868
 869   tree basetype = NULL_TREE, field;
 870   tree parm;
 871   tree rval, type;
 872   tree actual_name;
 873
 874   if (exp == NULL_TREE)
 875     return;                     /* complain about this later */
 876
 877   type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
 878
 879   if (name == NULL_TREE && IS_AGGR_TYPE (type))
 880     switch (CLASSTYPE_N_BASECLASSES (type))
 881       {
 882       case 0:
 883         error ("base class initializer specified, but no base class to initialize");
 884         return;
 885       case 1:
 886         basetype = TYPE_BINFO_BASETYPE (type, 0);
 887         break;
 888       default:
 889         error ("initializer for unnamed base class ambiguous");
 890         cp_error ("(type `%T' uses multiple inheritance)", type);
 891         return;
 892       }
 893
 894   if (init)
 895     {
 896       /* The grammar should not allow fields which have names
 897          that are TYPENAMEs.  Therefore, if the field has
 898          a non-NULL TREE_TYPE, we may assume that this is an
 899          attempt to initialize a base class member of the current
 900          type.  Otherwise, it is an attempt to initialize a
 901          member field.  */
 902
 903       if (init == void_type_node)
 904         init = NULL_TREE;
 905
 906       if (name == NULL_TREE || IDENTIFIER_HAS_TYPE_VALUE (name))
 907         {
 908           tree base_init;
 909
 910           if (name == NULL_TREE)
 911             {
 912 /*
 913               if (basetype)
 914                 name = TYPE_IDENTIFIER (basetype);
 915               else
 916                 {
 917                   error ("no base class to initialize");
 918                   return;
 919                 }
 920 */
 921             }
 922           else
 923             {
 924               basetype = IDENTIFIER_TYPE_VALUE (name);
 925               if (basetype != type
 926                   && ! binfo_member (basetype, TYPE_BINFO (type))
 927                   && ! binfo_member (basetype, CLASSTYPE_VBASECLASSES (type)))
 928                 {
 929                   if (IDENTIFIER_CLASS_VALUE (name))
 930                     goto try_member;
 931                   if (TYPE_USES_VIRTUAL_BASECLASSES (type))
 932                     error ("type `%s' is not an immediate or virtual basetype for `%s'",
 933                            IDENTIFIER_POINTER (name),
 934                            TYPE_NAME_STRING (type));
 935                   else
 936                     error ("type `%s' is not an immediate basetype for `%s'",
 937                            IDENTIFIER_POINTER (name),
 938                            TYPE_NAME_STRING (type));
 939                   return;
 940                 }
 941             }
 942
 943           if (purpose_member (name, current_base_init_list))
 944             {
 945               error ("base class `%s' already initialized",
 946                      IDENTIFIER_POINTER (name));
 947               return;
 948             }
 949
 950           base_init = build_tree_list (name, init);
 951           TREE_TYPE (base_init) = basetype;
 952           current_base_init_list = chainon (current_base_init_list, base_init);
 953         }
 954       else
 955         {
 956           tree member_init;
 957
 958         try_member:
 959           field = lookup_field (type, name, 1, 0);
 960
 961           if (! member_init_ok_or_else (field, type, IDENTIFIER_POINTER (name)))
 962             return;
 963
 964           if (purpose_member (name, current_member_init_list))
 965             {
 966               error ("field `%s' already initialized", IDENTIFIER_POINTER (name));
 967               return;
 968             }
 969
 970           member_init = build_tree_list (name, init);
 971           TREE_TYPE (member_init) = TREE_TYPE (field);
 972           current_member_init_list = chainon (current_member_init_list, member_init);
 973         }
 974       return;
 975     }
 976   else if (name == NULL_TREE)
 977     {
 978       compiler_error ("expand_member_init: name == NULL_TREE");
 979       return;
 980     }
 981
 982   basetype = type;
 983   field = lookup_field (basetype, name, 0, 0);
 984
 985   if (! member_init_ok_or_else (field, basetype, IDENTIFIER_POINTER (name)))
 986     return;
 987
 988   /* now see if there is a constructor for this type
 989      which will take these args. */
 990
 991   if (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (field)))
 992     {
 993       tree parmtypes, fndecl;
 994
 995       if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
 996         {
 997           /* just know that we've seen something for this node */
 998           DECL_INITIAL (exp) = error_mark_node;
 999           TREE_USED (exp) = 1;
1000         }
1001       type = TYPE_MAIN_VARIANT (TREE_TYPE (field));
1002       actual_name = TYPE_IDENTIFIER (type);
1003       parm = build_component_ref (exp, name, 0, 0);
1004
1005       /* Now get to the constructor.  */
1006       fndecl = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0);
1007       /* Get past destructor, if any.  */
1008       if (TYPE_HAS_DESTRUCTOR (type))
1009         fndecl = DECL_CHAIN (fndecl);
1010
1011       if (fndecl)
1012         my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 209);
1013
1014       /* If the field is unique, we can use the parameter
1015          types to guide possible type instantiation.  */
1016       if (DECL_CHAIN (fndecl) == NULL_TREE)
1017         {
1018           /* There was a confusion here between
1019              FIELD and FNDECL.  The following code
1020              should be correct, but abort is here
1021              to make sure.  */
1022           my_friendly_abort (48);
1023           parmtypes = FUNCTION_ARG_CHAIN (fndecl);
1024         }
1025       else
1026         {
1027           parmtypes = NULL_TREE;
1028           fndecl = NULL_TREE;
1029         }
1030
1031       init = convert_arguments (parm, parmtypes, NULL_TREE, fndecl, LOOKUP_NORMAL);
1032       if (init == NULL_TREE || TREE_TYPE (init) != error_mark_node)
1033         rval = build_method_call (NULL_TREE, actual_name, init, NULL_TREE, LOOKUP_NORMAL);
1034       else
1035         return;
1036
1037       if (rval != error_mark_node)
1038         {
1039           /* Now, fill in the first parm with our guy */
1040           TREE_VALUE (TREE_OPERAND (rval, 1))
1041             = build_unary_op (ADDR_EXPR, parm, 0);
1042           TREE_TYPE (rval) = ptr_type_node;
1043           TREE_SIDE_EFFECTS (rval) = 1;
1044         }
1045     }
1046   else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1047     {
1048       parm = build_component_ref (exp, name, 0, 0);
1049       expand_aggr_init (parm, NULL_TREE, 0, 0);
1050       rval = error_mark_node;
1051     }
1052
1053   /* Now initialize the member.  It does not have to
1054      be of aggregate type to receive initialization.  */
1055   if (rval != error_mark_node)
1056     expand_expr_stmt (rval);
1057 }
1058
1059 /* This is like `expand_member_init', only it stores one aggregate
1060    value into another.
1061
1062    INIT comes in two flavors: it is either a value which
1063    is to be stored in EXP, or it is a parameter list
1064    to go to a constructor, which will operate on EXP.
1065    If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1066    the initializer, if FLAGS is 0, then it is the (init) form.
1067    If `init' is a CONSTRUCTOR, then we emit a warning message,
1068    explaining that such initializations are invalid.
1069
1070    ALIAS_THIS is nonzero iff we are initializing something which is
1071    essentially an alias for C_C_D.  In this case, the base constructor
1072    may move it on us, and we must keep track of such deviations.
1073
1074    If INIT resolves to a CALL_EXPR which happens to return
1075    something of the type we are looking for, then we know
1076    that we can safely use that call to perform the
1077    initialization.
1078
1079    The virtual function table pointer cannot be set up here, because
1080    we do not really know its type.
1081
1082    Virtual baseclass pointers are also set up here.
1083
1084    This never calls operator=().
1085
1086    When initializing, nothing is CONST.
1087
1088    A default copy constructor may have to be used to perform the
1089    initialization.
1090
1091    A constructor or a conversion operator may have to be used to
1092    perform the initialization, but not both, as it would be ambiguous.
1093    */
1094
1095 void
1096 expand_aggr_init (exp, init, alias_this, flags)
1097      tree exp, init;
1098      int alias_this;
1099      int flags;
1100 {
1101   tree type = TREE_TYPE (exp);
1102   int was_const = TREE_READONLY (exp);
1103
1104   if (init == error_mark_node)
1105     return;
1106
1107   TREE_READONLY (exp) = 0;
1108
1109   if (TREE_CODE (type) == ARRAY_TYPE)
1110     {
1111       /* Must arrange to initialize each element of EXP
1112          from elements of INIT.  */
1113       int was_const_elts = TYPE_READONLY (TREE_TYPE (type));
1114       tree itype = init ? TREE_TYPE (init) : NULL_TREE;
1115       if (was_const_elts)
1116         {
1117           TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1118           if (init)
1119             TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1120         }
1121       if (init && TREE_TYPE (init) == NULL_TREE)
1122         {
1123           /* Handle bad initializers like:
1124              class COMPLEX {
1125              public:
1126                double re, im;
1127                COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1128                ~COMPLEX() {};
1129              };
1130
1131              int main(int argc, char **argv) {
1132                COMPLEX zees(1.0, 0.0)[10];
1133              }
1134           */
1135           error ("bad array initializer");
1136           return;
1137         }
1138       expand_vec_init (exp, exp, array_type_nelts (type), init,
1139                        init && comptypes (TREE_TYPE (init), TREE_TYPE (exp), 1));
1140       TREE_READONLY (exp) = was_const;
1141       TREE_TYPE (exp) = type;
1142       if (init)
1143         TREE_TYPE (init) = itype;
1144       return;
1145     }
1146
1147   if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1148     /* just know that we've seen something for this node */
1149     TREE_USED (exp) = 1;
1150
1151 #if 0
1152   /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
1153      constructor as parameters to an implicit GNU C++ constructor.  */
1154   if (init && TREE_CODE (init) == CONSTRUCTOR
1155       && TYPE_HAS_CONSTRUCTOR (type)
1156       && TREE_TYPE (init) == type)
1157     init = CONSTRUCTOR_ELTS (init);
1158 #endif
1159   expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1160                       init, alias_this, LOOKUP_NORMAL|flags);
1161   TREE_READONLY (exp) = was_const;
1162 }
1163
1164 static void
1165 expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags)
1166      tree binfo;
1167      tree true_exp, exp;
1168      tree type;
1169      tree init;
1170      int alias_this;
1171      int flags;
1172 {
1173   /* It fails because there may not be a constructor which takes
1174      its own type as the first (or only parameter), but which does
1175      take other types via a conversion.  So, if the thing initializing
1176      the expression is a unit element of type X, first try X(X&),
1177      followed by initialization by X.  If neither of these work
1178      out, then look hard.  */
1179   tree rval;
1180   tree parms;
1181
1182   if (init == NULL_TREE
1183       || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1184     {
1185       parms = init;
1186       if (parms)
1187         init = TREE_VALUE (parms);
1188     }
1189   else if (TREE_CODE (init) == INDIRECT_REF && TREE_HAS_CONSTRUCTOR (init)
1190            && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (init)))
1191     {
1192       rval = convert_for_initialization (exp, type, init, 0, 0, 0, 0);
1193       TREE_USED (rval) = 1;
1194       expand_expr_stmt (rval);
1195       return;
1196     }
1197   else
1198     parms = build_tree_list (NULL_TREE, init);
1199
1200   if (TYPE_USES_VIRTUAL_BASECLASSES (type))
1201     {
1202       if (true_exp == exp)
1203         parms = tree_cons (NULL_TREE, integer_one_node, parms);
1204       else
1205         parms = tree_cons (NULL_TREE, integer_zero_node, parms);
1206       flags |= LOOKUP_HAS_IN_CHARGE;
1207     }
1208
1209   if (init && TREE_CHAIN (parms) == NULL_TREE
1210       && TYPE_HAS_CONSTRUCTOR (type)
1211       && ! TYPE_NEEDS_CONSTRUCTING (type)
1212       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (init)))
1213     {
1214       rval = build (INIT_EXPR, type, exp, init);
1215       TREE_SIDE_EFFECTS (rval) = 1;
1216       expand_expr_stmt (rval);
1217     }
1218   else
1219     {
1220       rval = build_method_call (exp, constructor_name_full (type),
1221                                 parms, binfo, flags);
1222
1223       /* Private, protected, or otherwise unavailable.  */
1224       if (rval == error_mark_node)
1225         {
1226           if (flags & LOOKUP_COMPLAIN)
1227             cp_error ("in base initialization for %sclass `%T'",
1228                       TREE_VIA_VIRTUAL (binfo) ? "virtual base " : "",
1229                       binfo);
1230         }
1231       else if (rval == NULL_TREE)
1232         my_friendly_abort (361);
1233       else
1234         {
1235           /* p. 222: if the base class assigns to `this', then that
1236              value is used in the derived class.  */
1237           if ((flag_this_is_variable & 1) && alias_this)
1238             {
1239               TREE_TYPE (rval) = TREE_TYPE (current_class_decl);
1240               expand_assignment (current_class_decl, rval, 0, 0);
1241             }
1242           else
1243             expand_expr_stmt (rval);
1244         }
1245     }
1246 }
1247
1248 /* This function is responsible for initializing EXP with INIT
1249    (if any).
1250
1251    BINFO is the binfo of the type for who we are performing the
1252    initialization.  For example, if W is a virtual base class of A and B,
1253    and C : A, B.
1254    If we are initializing B, then W must contain B's W vtable, whereas
1255    were we initializing C, W must contain C's W vtable.
1256
1257    TRUE_EXP is nonzero if it is the true expression being initialized.
1258    In this case, it may be EXP, or may just contain EXP.  The reason we
1259    need this is because if EXP is a base element of TRUE_EXP, we
1260    don't necessarily know by looking at EXP where its virtual
1261    baseclass fields should really be pointing.  But we do know
1262    from TRUE_EXP.  In constructors, we don't know anything about
1263    the value being initialized.
1264
1265    ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1266
1267    FLAGS is just passes to `build_method_call'.  See that function for
1268    its description.  */
1269
1270 static void
1271 expand_aggr_init_1 (binfo, true_exp, exp, init, alias_this, flags)
1272      tree binfo;
1273      tree true_exp, exp;
1274      tree init;
1275      int alias_this;
1276      int flags;
1277 {
1278   tree type = TREE_TYPE (exp);
1279   tree init_type = NULL_TREE;
1280
1281   my_friendly_assert (init != error_mark_node && type != error_mark_node, 211);
1282
1283   /* Use a function returning the desired type to initialize EXP for us.
1284      If the function is a constructor, and its first argument is
1285      NULL_TREE, know that it was meant for us--just slide exp on
1286      in and expand the constructor.  Constructors now come
1287      as TARGET_EXPRs.  */
1288   if (init)
1289     {
1290       tree init_list = NULL_TREE;
1291
1292       if (TREE_CODE (init) == TREE_LIST)
1293         {
1294           init_list = init;
1295           if (TREE_CHAIN (init) == NULL_TREE)
1296             init = TREE_VALUE (init);
1297         }
1298
1299       init_type = TREE_TYPE (init);
1300
1301       if (TREE_CODE (init) != TREE_LIST)
1302         {
1303           if (TREE_CODE (init_type) == ERROR_MARK)
1304             return;
1305
1306 #if 0
1307           /* These lines are found troublesome 5/11/89.  */
1308           if (TREE_CODE (init_type) == REFERENCE_TYPE)
1309             init_type = TREE_TYPE (init_type);
1310 #endif
1311
1312           /* This happens when we use C++'s functional cast notation.
1313              If the types match, then just use the TARGET_EXPR
1314              directly.  Otherwise, we need to create the initializer
1315              separately from the object being initialized.  */
1316           if (TREE_CODE (init) == TARGET_EXPR)
1317             {
1318               if (TYPE_MAIN_VARIANT (init_type) == TYPE_MAIN_VARIANT (type))
1319                 {
1320                   if (TREE_CODE (exp) == VAR_DECL
1321                       || TREE_CODE (exp) == RESULT_DECL)
1322                     /* Unify the initialization targets.  */
1323                     DECL_RTL (TREE_OPERAND (init, 0)) = DECL_RTL (exp);
1324                   else
1325                     DECL_RTL (TREE_OPERAND (init, 0)) = expand_expr (exp, NULL_RTX, 0, 0);
1326
1327                   expand_expr_stmt (init);
1328                   return;
1329                 }
1330               else
1331                 {
1332                   init = TREE_OPERAND (init, 1);
1333                   init = build (CALL_EXPR, init_type,
1334                                 TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), 0);
1335                   TREE_SIDE_EFFECTS (init) = 1;
1336                     if (init_list)
1337                       TREE_VALUE (init_list) = init;
1338                 }
1339             }
1340
1341           if (init_type == type && TREE_CODE (init) == CALL_EXPR
1342 #if 0
1343               /* It is valid to directly initialize from a CALL_EXPR
1344                  without going through X(X&), apparently.  */
1345               && ! TYPE_GETS_INIT_REF (type)
1346 #endif
1347               )
1348             {
1349               /* A CALL_EXPR is a legitimate form of initialization, so
1350                  we should not print this warning message.  */
1351 #if 0
1352               /* Should have gone away due to 5/11/89 change.  */
1353               if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
1354                 init = convert_from_reference (init);
1355 #endif
1356               expand_assignment (exp, init, 0, 0);
1357               if (exp == DECL_RESULT (current_function_decl))
1358                 {
1359                   /* Failing this assertion means that the return value
1360                      from receives multiple initializations.  */
1361                   my_friendly_assert (DECL_INITIAL (exp) == NULL_TREE
1362                                       || DECL_INITIAL (exp) == error_mark_node,
1363                                       212);
1364                   DECL_INITIAL (exp) = init;
1365                 }
1366               return;
1367             }
1368           else if (init_type == type
1369                    && TREE_CODE (init) == COND_EXPR)
1370             {
1371               /* Push value to be initialized into the cond, where possible.
1372                  Avoid spurious warning messages when initializing the
1373                  result of this function.  */
1374               TREE_OPERAND (init, 1)
1375                 = build_modify_expr (exp, INIT_EXPR, TREE_OPERAND (init, 1));
1376               if (exp == DECL_RESULT (current_function_decl))
1377                 DECL_INITIAL (exp) = NULL_TREE;
1378               TREE_OPERAND (init, 2)
1379                 = build_modify_expr (exp, INIT_EXPR, TREE_OPERAND (init, 2));
1380               if (exp == DECL_RESULT (current_function_decl))
1381                 DECL_INITIAL (exp) = init;
1382               TREE_SIDE_EFFECTS (init) = 1;
1383               expand_expr (init, const0_rtx, VOIDmode, 0);
1384               free_temp_slots ();
1385               return;
1386             }
1387         }
1388
1389       /* We did not know what we were initializing before.  Now we do.  */
1390       if (TREE_CODE (init) == TARGET_EXPR)
1391         {
1392           tree tmp = TREE_OPERAND (TREE_OPERAND (init, 1), 1);
1393
1394           if (TREE_CODE (TREE_VALUE (tmp)) == NOP_EXPR
1395               && TREE_OPERAND (TREE_VALUE (tmp), 0) == integer_zero_node)
1396             {
1397               /* In order for this to work for RESULT_DECLs, if their
1398                  type has a constructor, then they must be BLKmode
1399                  so that they will be meaningfully addressable.  */
1400               tree arg = build_unary_op (ADDR_EXPR, exp, 0);
1401               init = TREE_OPERAND (init, 1);
1402               init = build (CALL_EXPR, build_pointer_type (TREE_TYPE (init)),
1403                             TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), 0);
1404               TREE_SIDE_EFFECTS (init) = 1;
1405               TREE_VALUE (TREE_OPERAND (init, 1))
1406                 = convert_pointer_to (TREE_TYPE (TREE_TYPE (TREE_VALUE (tmp))), arg);
1407
1408               if (alias_this)
1409                 {
1410                   expand_assignment (current_function_decl, init, 0, 0);
1411                   return;
1412                 }
1413               if (exp == DECL_RESULT (current_function_decl))
1414                 {
1415                   if (DECL_INITIAL (DECL_RESULT (current_function_decl)))
1416                     fatal ("return value from function receives multiple initializations");
1417                   DECL_INITIAL (exp) = init;
1418                 }
1419               expand_expr_stmt (init);
1420               return;
1421             }
1422         }
1423
1424       if (TREE_CODE (exp) == VAR_DECL
1425           && TREE_CODE (init) == CONSTRUCTOR
1426           && TREE_HAS_CONSTRUCTOR (init))
1427         {
1428           tree t = store_init_value (exp, init);
1429           if (!t)
1430             {
1431               expand_decl_init (exp);
1432               return;
1433             }
1434           t = build (INIT_EXPR, type, exp, init);
1435           TREE_SIDE_EFFECTS (t) = 1;
1436           expand_expr_stmt (t);
1437           return;
1438         }
1439
1440       /* Handle this case: when calling a constructor: xyzzy foo(bar);
1441          which really means:  xyzzy foo = bar; Ugh!
1442
1443          More useful for this case: xyzzy *foo = new xyzzy (bar);  */
1444
1445       if (! TYPE_NEEDS_CONSTRUCTING (type) && ! IS_AGGR_TYPE (type))
1446         {
1447           if (init_list && TREE_CHAIN (init_list))
1448             {
1449               warning ("initializer list being treated as compound expression");
1450               init = convert (type, build_compound_expr (init_list));
1451               if (init == error_mark_node)
1452                 return;
1453             }
1454
1455           expand_assignment (exp, init, 0, 0);
1456
1457           return;
1458         }
1459       /* See whether we can go through a type conversion operator.
1460          This wins over going through a non-existent constructor.  If
1461          there is a constructor, it is ambiguous.  */
1462       if (TREE_CODE (init) != TREE_LIST)
1463         {
1464           tree ttype = TREE_CODE (init_type) == REFERENCE_TYPE
1465             ? TREE_TYPE (init_type) : init_type;
1466
1467           if (ttype != type && IS_AGGR_TYPE (ttype))
1468             {
1469               tree rval = build_type_conversion (CONVERT_EXPR, type, init, 0);
1470
1471               if (rval)
1472                 {
1473                   /* See if there is a constructor for``type'' that takes a
1474                      ``ttype''-typed object. */
1475                   tree parms = build_tree_list (NULL_TREE, init);
1476                   tree as_cons = NULL_TREE;
1477                   if (TYPE_HAS_CONSTRUCTOR (type))
1478                     as_cons = build_method_call (exp, constructor_name_full (type),
1479                                                  parms, binfo,
1480                                                  LOOKUP_SPECULATIVELY|LOOKUP_NO_CONVERSION);
1481                   if (as_cons != NULL_TREE && as_cons != error_mark_node)
1482                     /* ANSI C++ June 5 1992 WP 12.3.2.6.1 */
1483                     cp_error ("ambiguity between conversion to `%T' and constructor",
1484                               type);
1485                   else
1486                     expand_assignment (exp, rval, 0, 0);
1487                   return;
1488                 }
1489             }
1490         }
1491     }
1492
1493   /* Handle default copy constructors here, does not matter if there is
1494      a constructor or not.  */
1495   if (type == init_type && IS_AGGR_TYPE (type)
1496       && init && TREE_CODE (init) != TREE_LIST)
1497     expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags);
1498   /* Not sure why this is here... */
1499   else if (TYPE_HAS_CONSTRUCTOR (type))
1500     expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags);
1501   else if (TREE_CODE (type) == ARRAY_TYPE)
1502     {
1503       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
1504         expand_vec_init (exp, exp, array_type_nelts (type), init, 0);
1505       else if (TYPE_VIRTUAL_P (TREE_TYPE (type)))
1506         sorry ("arrays of objects with virtual functions but no constructors");
1507     }
1508   else
1509     expand_recursive_init (binfo, true_exp, exp, init,
1510                            CLASSTYPE_BASE_INIT_LIST (type), alias_this);
1511 }
1512
1513 /* A pointer which holds the initializer.  First call to
1514    expand_aggr_init gets this value pointed to, and sets it to init_null.  */
1515 static tree *init_ptr, init_null;
1516
1517 /* Subroutine of expand_recursive_init:
1518
1519    ADDR is the address of the expression being initialized.
1520    INIT_LIST is the cons-list of initializations to be performed.
1521    ALIAS_THIS is its same, lovable self.  */
1522 static void
1523 expand_recursive_init_1 (binfo, true_exp, addr, init_list, alias_this)
1524      tree binfo, true_exp, addr;
1525      tree init_list;
1526      int alias_this;
1527 {
1528   while (init_list)
1529     {
1530       if (TREE_PURPOSE (init_list))
1531         {
1532           if (TREE_CODE (TREE_PURPOSE (init_list)) == FIELD_DECL)
1533             {
1534               tree member = TREE_PURPOSE (init_list);
1535               tree subexp = build_indirect_ref (convert_pointer_to (TREE_VALUE (init_list), addr), NULL_PTR);
1536               tree member_base = build (COMPONENT_REF, TREE_TYPE (member), subexp, member);
1537               if (IS_AGGR_TYPE (TREE_TYPE (member)))
1538                 expand_aggr_init (member_base, DECL_INITIAL (member), 0, 0);
1539               else if (TREE_CODE (TREE_TYPE (member)) == ARRAY_TYPE
1540                        && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (member)))
1541                 {
1542                   member_base = save_expr (default_conversion (member_base));
1543                   expand_vec_init (member, member_base,
1544                                    array_type_nelts (TREE_TYPE (member)),
1545                                    DECL_INITIAL (member), 0);
1546                 }
1547               else
1548                 expand_expr_stmt (build_modify_expr (member_base, INIT_EXPR, DECL_INITIAL (member)));
1549             }
1550           else if (TREE_CODE (TREE_PURPOSE (init_list)) == TREE_LIST)
1551             {
1552               expand_recursive_init_1 (binfo, true_exp, addr, TREE_PURPOSE (init_list), alias_this);
1553               expand_recursive_init_1 (binfo, true_exp, addr, TREE_VALUE (init_list), alias_this);
1554             }
1555           else if (TREE_CODE (TREE_PURPOSE (init_list)) == ERROR_MARK)
1556             {
1557               /* Only initialize the virtual function tables if we
1558                  are initializing the ultimate users of those vtables.  */
1559               if (TREE_VALUE (init_list))
1560                 {
1561                   /* We have to ensure that the first argment to
1562                      expand_virtual_init is in binfo's hierarchy.  */
1563                   /* Is it the case that this is exactly the right binfo? */
1564                   /* If it is ok, then fixup expand_virtual_init, to make
1565                      it much simpler. */
1566                   expand_virtual_init (get_binfo (TREE_VALUE (init_list), binfo, 0),
1567                                       addr);
1568                   if (TREE_VALUE (init_list) == binfo
1569                       && TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
1570                     expand_indirect_vtbls_init (binfo, true_exp, addr, 1);
1571                 }
1572             }
1573           else
1574             my_friendly_abort (49);
1575         }
1576       else if (TREE_VALUE (init_list)
1577                && TREE_CODE (TREE_VALUE (init_list)) == TREE_VEC)
1578         {
1579           tree subexp = build_indirect_ref (convert_pointer_to (TREE_VALUE (init_list), addr), NULL_PTR);
1580           expand_aggr_init_1 (binfo, true_exp, subexp, *init_ptr,
1581                               alias_this && BINFO_OFFSET_ZEROP (TREE_VALUE (init_list)),
1582                               LOOKUP_COMPLAIN);
1583
1584           /* INIT_PTR is used up.  */
1585           init_ptr = &init_null;
1586         }
1587       else
1588         my_friendly_abort (50);
1589       init_list = TREE_CHAIN (init_list);
1590     }
1591 }
1592
1593 /* Initialize EXP with INIT.  Type EXP does not have a constructor,
1594    but it has a baseclass with a constructor or a virtual function
1595    table which needs initializing.
1596
1597    INIT_LIST is a cons-list describing what parts of EXP actually
1598    need to be initialized.  INIT is given to the *unique*, first
1599    constructor within INIT_LIST.  If there are multiple first
1600    constructors, such as with multiple inheritance, INIT must
1601    be zero or an ambiguity error is reported.
1602
1603    ALIAS_THIS is passed from `expand_aggr_init'.  See comments
1604    there.  */
1605
1606 static void
1607 expand_recursive_init (binfo, true_exp, exp, init, init_list, alias_this)
1608      tree binfo, true_exp, exp, init;
1609      tree init_list;
1610      int alias_this;
1611 {
1612   tree *old_init_ptr = init_ptr;
1613   tree addr = build_unary_op (ADDR_EXPR, exp, 0);
1614   init_ptr = &init;
1615
1616   if (true_exp == exp && TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
1617     {
1618       expand_aggr_vbase_init (binfo, exp, addr, init_list);
1619       expand_indirect_vtbls_init (binfo, true_exp, addr, 1);
1620     }
1621   expand_recursive_init_1 (binfo, true_exp, addr, init_list, alias_this);
1622
1623   if (*init_ptr)
1624     {
1625       tree type = TREE_TYPE (exp);
1626
1627       if (TREE_CODE (type) == REFERENCE_TYPE)
1628         type = TREE_TYPE (type);
1629       if (IS_AGGR_TYPE (type))
1630         cp_error ("unexpected argument to constructor `%T'", type);
1631       else
1632         error ("unexpected argument to constructor");
1633     }
1634   init_ptr = old_init_ptr;
1635 }
1636
1637 /* Report an error if NAME is not the name of a user-defined,
1638    aggregate type.  If OR_ELSE is nonzero, give an error message.  */
1639 int
1640 is_aggr_typedef (name, or_else)
1641      tree name;
1642      int or_else;
1643 {
1644   tree type;
1645
1646   if (name == error_mark_node)
1647     return 0;
1648
1649   if (IDENTIFIER_HAS_TYPE_VALUE (name))
1650     type = IDENTIFIER_TYPE_VALUE (name);
1651   else
1652     {
1653       if (or_else)
1654         cp_error ("`%T' is not an aggregate typedef", name);
1655       return 0;
1656     }
1657
1658   if (! IS_AGGR_TYPE (type)
1659       && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
1660     {
1661       if (or_else)
1662         cp_error ("`%T' is not an aggregate type", type);
1663       return 0;
1664     }
1665   return 1;
1666 }
1667
1668 /* Like is_aggr_typedef, but returns typedef if successful.  */
1669 tree
1670 get_aggr_from_typedef (name, or_else)
1671      tree name;
1672      int or_else;
1673 {
1674   tree type;
1675
1676   if (name == error_mark_node)
1677     return NULL_TREE;
1678
1679   if (IDENTIFIER_HAS_TYPE_VALUE (name))
1680     type = IDENTIFIER_TYPE_VALUE (name);
1681   else
1682     {
1683       if (or_else)
1684         cp_error ("`%T' fails to be an aggregate typedef", name);
1685       return NULL_TREE;
1686     }
1687
1688   if (! IS_AGGR_TYPE (type)
1689       && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
1690     {
1691       if (or_else)
1692         cp_error ("type `%T' is of non-aggregate type", type);
1693       return NULL_TREE;
1694     }
1695   return type;
1696 }
1697
1698 tree
1699 get_type_value (name)
1700      tree name;
1701 {
1702   if (name == error_mark_node)
1703     return NULL_TREE;
1704
1705   if (IDENTIFIER_HAS_TYPE_VALUE (name))
1706     return IDENTIFIER_TYPE_VALUE (name);
1707   else
1708     return NULL_TREE;
1709 }
1710
1711 \f
1712 /* This code could just as well go in `class.c', but is placed here for
1713    modularity.  */
1714
1715 /* For an expression of the form CNAME :: NAME (PARMLIST), build
1716    the appropriate function call.  */
1717 tree
1718 build_member_call (cname, name, parmlist)
1719      tree cname, name, parmlist;
1720 {
1721   tree type, t;
1722   tree method_name = name;
1723   int dtor = 0;
1724   int dont_use_this = 0;
1725   tree basetype_path, decl;
1726
1727   if (TREE_CODE (method_name) == BIT_NOT_EXPR)
1728     {
1729       method_name = TREE_OPERAND (method_name, 0);
1730       dtor = 1;
1731     }
1732
1733   if (TREE_CODE (cname) == SCOPE_REF)
1734     cname = resolve_scope_to_name (NULL_TREE, cname);
1735
1736   if (cname == NULL_TREE || ! (type = get_aggr_from_typedef (cname, 1)))
1737     return error_mark_node;
1738
1739   /* An operator we did not like.  */
1740   if (name == NULL_TREE)
1741     return error_mark_node;
1742
1743   if (dtor)
1744     {
1745 #if 0
1746       /* Everything can explicitly call a destructor; see 12.4 */
1747       if (! TYPE_HAS_DESTRUCTOR (type))
1748         cp_error ("type `%#T' does not have a destructor", type);
1749       else
1750 #endif
1751       cp_error ("cannot call destructor `%T::~%T' without object", type,
1752                 method_name);
1753       return error_mark_node;
1754     }
1755
1756   /* No object?  Then just fake one up, and let build_method_call
1757      figure out what to do.  */
1758   if (current_class_type == 0
1759       || get_base_distance (type, current_class_type, 0, &basetype_path) == -1)
1760     dont_use_this = 1;
1761
1762   if (dont_use_this)
1763     {
1764       basetype_path = TYPE_BINFO (type);
1765       decl = build1 (NOP_EXPR, TYPE_POINTER_TO (type), error_mark_node);
1766     }
1767   else if (current_class_decl == 0)
1768     {
1769       dont_use_this = 1;
1770       decl = build1 (NOP_EXPR, TYPE_POINTER_TO (type), error_mark_node);
1771     }
1772   else
1773     {
1774       tree olddecl = current_class_decl;
1775       tree oldtype = TREE_TYPE (TREE_TYPE (olddecl));
1776       if (oldtype != type)
1777         {
1778           tree newtype = build_type_variant (type, TYPE_READONLY (oldtype),
1779                                              TYPE_VOLATILE (oldtype));
1780           decl = convert_force (build_pointer_type (newtype), olddecl, 0);
1781         }
1782       else
1783         decl = olddecl;
1784     }
1785
1786   decl = build_indirect_ref (decl, NULL_PTR);
1787
1788   if (t = lookup_fnfields (basetype_path, method_name, 0))
1789     return build_method_call (decl, method_name, parmlist, basetype_path,
1790                               LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
1791   if (TREE_CODE (name) == IDENTIFIER_NODE
1792       && ((t = lookup_field (TYPE_BINFO (type), name, 1, 0))))
1793     {
1794       if (t == error_mark_node)
1795         return error_mark_node;
1796       if (TREE_CODE (t) == FIELD_DECL)
1797         {
1798           if (dont_use_this)
1799             {
1800               cp_error ("invalid use of non-static field `%D'", t);
1801               return error_mark_node;
1802             }
1803           decl = build (COMPONENT_REF, TREE_TYPE (t), decl, t);
1804         }
1805       else if (TREE_CODE (t) == VAR_DECL)
1806         decl = t;
1807       else
1808         {
1809           cp_error ("invalid use of member `%D'", t);
1810           return error_mark_node;
1811         }
1812       if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl))
1813           && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (decl)))
1814         return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, decl, parmlist, NULL_TREE);
1815       return build_function_call (decl, parmlist);
1816     }
1817   else
1818     {
1819       cp_error ("no method `%T::%D'", type, name);
1820       return error_mark_node;
1821     }
1822 }
1823
1824 /* Build a reference to a member of an aggregate.  This is not a
1825    C++ `&', but really something which can have its address taken,
1826    and then act as a pointer to member, for example CNAME :: FIELD
1827    can have its address taken by saying & CNAME :: FIELD.
1828
1829    @@ Prints out lousy diagnostics for operator <typename>
1830    @@ fields.
1831
1832    @@ This function should be rewritten and placed in search.c.  */
1833 tree
1834 build_offset_ref (cname, name)
1835      tree cname, name;
1836 {
1837   tree decl, type, fnfields, fields, t = error_mark_node;
1838   tree basetypes = NULL_TREE;
1839   int dtor = 0;
1840
1841   if (TREE_CODE (cname) == SCOPE_REF)
1842     cname = resolve_scope_to_name (NULL_TREE, cname);
1843
1844   if (cname == NULL_TREE || ! is_aggr_typedef (cname, 1))
1845     return error_mark_node;
1846
1847   type = IDENTIFIER_TYPE_VALUE (cname);
1848
1849   if (TREE_CODE (name) == BIT_NOT_EXPR)
1850     {
1851       dtor = 1;
1852       name = TREE_OPERAND (name, 0);
1853     }
1854
1855   if (TYPE_SIZE (type) == 0)
1856     {
1857       t = IDENTIFIER_CLASS_VALUE (name);
1858       if (t == 0)
1859         {
1860           cp_error ("incomplete type `%T' does not have member `%D'", type,
1861                       name);
1862           return error_mark_node;
1863         }
1864       if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == VAR_DECL
1865           || TREE_CODE (t) == CONST_DECL)
1866         {
1867           TREE_USED (t) = 1;
1868           return t;
1869         }
1870       if (TREE_CODE (t) == FIELD_DECL)
1871         sorry ("use of member in incomplete aggregate type");
1872       else if (TREE_CODE (t) == FUNCTION_DECL)
1873         sorry ("use of member function in incomplete aggregate type");
1874       else
1875         my_friendly_abort (52);
1876       return error_mark_node;
1877     }
1878
1879 #if 0
1880   if (TREE_CODE (name) == TYPE_EXPR)
1881     /* Pass a TYPE_DECL to build_component_type_expr.  */
1882     return build_component_type_expr (TYPE_NAME (TREE_TYPE (cname)),
1883                                       name, NULL_TREE, 1);
1884 #endif
1885
1886   if (current_class_type == 0
1887       || get_base_distance (type, current_class_type, 0, &basetypes) == -1)
1888     {
1889       basetypes = TYPE_BINFO (type);
1890       decl = build1 (NOP_EXPR,
1891                      IDENTIFIER_TYPE_VALUE (cname),
1892                      error_mark_node);
1893     }
1894   else if (current_class_decl == 0)
1895     decl = build1 (NOP_EXPR, IDENTIFIER_TYPE_VALUE (cname),
1896                    error_mark_node);
1897   else
1898     decl = C_C_D;
1899
1900   fnfields = lookup_fnfields (basetypes, name, 1);
1901   fields = lookup_field (basetypes, name, 0, 0);
1902
1903   if (fields == error_mark_node || fnfields == error_mark_node)
1904     return error_mark_node;
1905
1906   /* A lot of this logic is now handled in lookup_field and
1907      lookup_fnfield. */
1908   if (fnfields)
1909     {
1910       basetypes = TREE_PURPOSE (fnfields);
1911
1912       /* Go from the TREE_BASELINK to the member function info.  */
1913       t = TREE_VALUE (fnfields);
1914
1915       if (fields)
1916         {
1917           if (DECL_FIELD_CONTEXT (fields) == DECL_FIELD_CONTEXT (t))
1918             {
1919               error ("ambiguous member reference: member `%s' defined as both field and function",
1920                      IDENTIFIER_POINTER (name));
1921               return error_mark_node;
1922             }
1923           if (UNIQUELY_DERIVED_FROM_P (DECL_FIELD_CONTEXT (fields), DECL_FIELD_CONTEXT (t)))
1924             ;
1925           else if (UNIQUELY_DERIVED_FROM_P (DECL_FIELD_CONTEXT (t), DECL_FIELD_CONTEXT (fields)))
1926             t = fields;
1927           else
1928             {
1929               error ("ambiguous member reference: member `%s' derives from distinct classes in multiple inheritance lattice");
1930               return error_mark_node;
1931             }
1932         }
1933
1934       if (t == TREE_VALUE (fnfields))
1935         {
1936           extern int flag_save_memoized_contexts;
1937
1938           if (DECL_CHAIN (t) == NULL_TREE || dtor)
1939             {
1940               enum access_type access;
1941
1942               /* unique functions are handled easily.  */
1943             unique:
1944               access = compute_access (basetypes, t);
1945               if (access == access_protected)
1946                 {
1947                   cp_error_at ("member function `%#D' is protected", t);
1948                   error ("in this context");
1949                   return error_mark_node;
1950                 }
1951               if (access == access_private)
1952                 {
1953                   cp_error_at ("member function `%#D' is private", t);
1954                   error ("in this context");
1955                   return error_mark_node;
1956                 }
1957               assemble_external (t);
1958               return build (OFFSET_REF, TREE_TYPE (t), decl, t);
1959             }
1960
1961           /* overloaded functions may need more work.  */
1962           if (cname == name)
1963             {
1964               if (TYPE_HAS_DESTRUCTOR (type)
1965                   && DECL_CHAIN (DECL_CHAIN (t)) == NULL_TREE)
1966                 {
1967                   t = DECL_CHAIN (t);
1968                   goto unique;
1969                 }
1970             }
1971           /* FNFIELDS is most likely allocated on the search_obstack,
1972              which will go away after this class scope.  If we need
1973              to save this value for later (either for memoization
1974              or for use as an initializer for a static variable), then
1975              do so here.
1976
1977              ??? The smart thing to do for the case of saving initializers
1978              is to resolve them before we're done with this scope.  */
1979           if (!TREE_PERMANENT (fnfields)
1980               && ((flag_save_memoized_contexts && global_bindings_p ())
1981                   || ! allocation_temporary_p ()))
1982             fnfields = copy_list (fnfields);
1983           t = build_tree_list (error_mark_node, fnfields);
1984           TREE_TYPE (t) = build_offset_type (type, unknown_type_node);
1985           return t;
1986         }
1987     }
1988
1989   /* Now that we know we are looking for a field, see if we
1990      have access to that field.  Lookup_field will give us the
1991      error message.  */
1992
1993   t = lookup_field (basetypes, name, 1, 0);
1994
1995   if (t == error_mark_node)
1996     return error_mark_node;
1997
1998   if (t == NULL_TREE)
1999     {
2000       cp_error ("`%D' is not a member of type `%T'", name, type);
2001       return error_mark_node;
2002     }
2003
2004   if (TREE_CODE (t) == TYPE_DECL)
2005     {
2006       TREE_USED (t) = 1;
2007       return t;
2008     }
2009   /* static class members and class-specific enum
2010      values can be returned without further ado.  */
2011   if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == CONST_DECL)
2012     {
2013       assemble_external (t);
2014       TREE_USED (t) = 1;
2015       return t;
2016     }
2017
2018   if (TREE_CODE (t) == FIELD_DECL && DECL_BIT_FIELD (t))
2019     {
2020       cp_error ("illegal pointer to bit field `%D'", t);
2021       return error_mark_node;
2022     }
2023
2024   /* static class functions too.  */
2025   if (TREE_CODE (t) == FUNCTION_DECL && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
2026     my_friendly_abort (53);
2027
2028   /* In member functions, the form `cname::name' is no longer
2029      equivalent to `this->cname::name'.  */
2030   return build (OFFSET_REF, build_offset_type (type, TREE_TYPE (t)), decl, t);
2031 }
2032
2033 /* Given an object EXP and a member function reference MEMBER,
2034    return the address of the actual member function.  */
2035 tree
2036 get_member_function (exp_addr_ptr, exp, member)
2037      tree *exp_addr_ptr;
2038      tree exp, member;
2039 {
2040   tree ctype = TREE_TYPE (exp);
2041   tree function = save_expr (build_unary_op (ADDR_EXPR, member, 0));
2042
2043   if (TYPE_VIRTUAL_P (ctype)
2044       || (flag_all_virtual == 1 && TYPE_OVERLOADS_METHOD_CALL_EXPR (ctype)))
2045     {
2046       tree e0, e1, e3;
2047       tree exp_addr;
2048
2049       /* Save away the unadulterated `this' pointer.  */
2050       exp_addr = save_expr (*exp_addr_ptr);
2051
2052       /* Cast function to signed integer.  */
2053       e0 = build1 (NOP_EXPR, integer_type_node, function);
2054
2055       /* There is a hack here that takes advantage of
2056          twos complement arithmetic, and the fact that
2057          there are more than one UNITS to the WORD.
2058          If the high bit is set for the `function',
2059          then we pretend it is a virtual function,
2060          and the array indexing will knock this bit
2061          out the top, leaving a valid index.  */
2062       if (UNITS_PER_WORD <= 1)
2063         my_friendly_abort (54);
2064
2065       e1 = build (GT_EXPR, boolean_type_node, e0, integer_zero_node);
2066       e1 = build_compound_expr (tree_cons (NULL_TREE, exp_addr,
2067                                            build_tree_list (NULL_TREE, e1)));
2068       e1 = save_expr (e1);
2069
2070       if (TREE_SIDE_EFFECTS (*exp_addr_ptr))
2071         {
2072           exp = build_indirect_ref (exp_addr, NULL_PTR);
2073           *exp_addr_ptr = exp_addr;
2074         }
2075
2076       /* This is really hairy: if the function pointer is a pointer
2077          to a non-virtual member function, then we can't go mucking
2078          with the `this' pointer (any more than we already have to
2079          this point).  If it is a pointer to a virtual member function,
2080          then we have to adjust the `this' pointer according to
2081          what the virtual function table tells us.  */
2082
2083       e3 = build_vfn_ref (exp_addr_ptr, exp, e0);
2084       my_friendly_assert (e3 != error_mark_node, 213);
2085
2086       /* Change this pointer type from `void *' to the
2087          type it is really supposed to be.  */
2088       TREE_TYPE (e3) = TREE_TYPE (function);
2089
2090       /* If non-virtual, use what we had originally.  Otherwise,
2091          use the value we get from the virtual function table.  */
2092       *exp_addr_ptr = build_conditional_expr (e1, exp_addr, *exp_addr_ptr);
2093
2094       function = build_conditional_expr (e1, function, e3);
2095     }
2096   return build_indirect_ref (function, NULL_PTR);
2097 }
2098
2099 /* If a OFFSET_REF made it through to here, then it did
2100    not have its address taken.  */
2101
2102 tree
2103 resolve_offset_ref (exp)
2104      tree exp;
2105 {
2106   tree type = TREE_TYPE (exp);
2107   tree base = NULL_TREE;
2108   tree member;
2109   tree basetype, addr;
2110
2111   if (TREE_CODE (exp) == TREE_LIST)
2112     return build_unary_op (ADDR_EXPR, exp, 0);
2113
2114   if (TREE_CODE (exp) != OFFSET_REF)
2115     {
2116       my_friendly_assert (TREE_CODE (type) == OFFSET_TYPE, 214);
2117       if (TYPE_OFFSET_BASETYPE (type) != current_class_type)
2118         {
2119           error ("object missing in use of pointer-to-member construct");
2120           return error_mark_node;
2121         }
2122       member = exp;
2123       type = TREE_TYPE (type);
2124       base = C_C_D;
2125     }
2126   else
2127     {
2128       member = TREE_OPERAND (exp, 1);
2129       base = TREE_OPERAND (exp, 0);
2130     }
2131
2132   if ((TREE_CODE (member) == VAR_DECL
2133        && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member)))
2134       || TREE_CODE (TREE_TYPE (member)) == FUNCTION_TYPE)
2135     {
2136       /* These were static members.  */
2137       if (mark_addressable (member) == 0)
2138         return error_mark_node;
2139       return member;
2140     }
2141
2142   /* Syntax error can cause a member which should
2143      have been seen as static to be grok'd as non-static.  */
2144   if (TREE_CODE (member) == FIELD_DECL && C_C_D == NULL_TREE)
2145     {
2146       if (TREE_ADDRESSABLE (member) == 0)
2147         {
2148           cp_error_at ("member `%D' is non-static in static member function context", member);
2149           error ("at this point in file");
2150           TREE_ADDRESSABLE (member) = 1;
2151         }
2152       return error_mark_node;
2153     }
2154
2155   /* The first case is really just a reference to a member of `this'.  */
2156   if (TREE_CODE (member) == FIELD_DECL
2157       && (base == C_C_D
2158           || (TREE_CODE (base) == NOP_EXPR
2159               && TREE_OPERAND (base, 0) == error_mark_node)))
2160     {
2161       tree basetype_path;
2162       enum access_type access;
2163
2164       if (TREE_CODE (exp) == OFFSET_REF && TREE_CODE (type) == OFFSET_TYPE)
2165         basetype = TYPE_OFFSET_BASETYPE (type);
2166       else
2167         basetype = DECL_CONTEXT (member);
2168
2169       base = current_class_decl;
2170
2171       if (get_base_distance (basetype, TREE_TYPE (TREE_TYPE (base)), 0, &basetype_path) < 0)
2172         {
2173           error_not_base_type (basetype, TREE_TYPE (TREE_TYPE (base)));
2174           return error_mark_node;
2175         }
2176       addr = convert_pointer_to (basetype, base);
2177       access = compute_access (basetype_path, member);
2178       if (access == access_public)
2179         return build (COMPONENT_REF, TREE_TYPE (member),
2180                       build_indirect_ref (addr, NULL_PTR), member);
2181       if (access == access_protected)
2182         {
2183           cp_error_at ("member `%D' is protected", member);
2184           error ("in this context");
2185           return error_mark_node;
2186         }
2187       if (access == access_private)
2188         {
2189           cp_error_at ("member `%D' is private", member);
2190           error ("in this context");
2191           return error_mark_node;
2192         }
2193       my_friendly_abort (55);
2194     }
2195
2196   /* If this is a reference to a member function, then return
2197      the address of the member function (which may involve going
2198      through the object's vtable), otherwise, return an expression
2199      for the dereferenced pointer-to-member construct.  */
2200   addr = build_unary_op (ADDR_EXPR, base, 0);
2201
2202   if (TREE_CODE (TREE_TYPE (member)) == METHOD_TYPE)
2203     {
2204       basetype = DECL_CLASS_CONTEXT (member);
2205       addr = convert_pointer_to (basetype, addr);
2206       return build_unary_op (ADDR_EXPR, get_member_function (&addr, build_indirect_ref (addr, NULL_PTR), member), 0);
2207     }
2208   else if (TREE_CODE (TREE_TYPE (member)) == OFFSET_TYPE)
2209     {
2210       basetype = TYPE_OFFSET_BASETYPE (TREE_TYPE (member));
2211       addr = convert_pointer_to (basetype, addr);
2212       member = convert (ptrdiff_type_node,
2213                         build_unary_op (ADDR_EXPR, member, 0));
2214       return build1 (INDIRECT_REF, type,
2215                      build (PLUS_EXPR, build_pointer_type (type),
2216                             addr, member));
2217     }
2218   else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member)))
2219     {
2220       return get_member_function_from_ptrfunc (&addr, member);
2221     }
2222   my_friendly_abort (56);
2223   /* NOTREACHED */
2224   return NULL_TREE;
2225 }
2226
2227 /* Return either DECL or its known constant value (if it has one).  */
2228
2229 tree
2230 decl_constant_value (decl)
2231      tree decl;
2232 {
2233   if (! TREE_THIS_VOLATILE (decl)
2234 #if 0
2235       /* These may be necessary for C, but they break C++.  */
2236       ! TREE_PUBLIC (decl)
2237       /* Don't change a variable array bound or initial value to a constant
2238          in a place where a variable is invalid.  */
2239       && ! pedantic
2240 #endif /* 0 */
2241       && DECL_INITIAL (decl) != 0
2242       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
2243       /* This is invalid if initial value is not constant.
2244          If it has either a function call, a memory reference,
2245          or a variable, then re-evaluating it could give different results.  */
2246       && TREE_CONSTANT (DECL_INITIAL (decl))
2247       /* Check for cases where this is sub-optimal, even though valid.  */
2248       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR
2249 #if 0
2250       /* We must allow this to work outside of functions so that
2251          static constants can be used for array sizes.  */
2252       && current_function_decl != 0
2253       && DECL_MODE (decl) != BLKmode
2254 #endif
2255       )
2256     return DECL_INITIAL (decl);
2257   return decl;
2258 }
2259 \f
2260 /* Friend handling routines.  */
2261 /* Friend data structures:
2262
2263    Lists of friend functions come from TYPE_DECL nodes.  Since all
2264    aggregate types are automatically typedef'd, these nodes are guaranteed
2265    to exist.
2266
2267    The TREE_PURPOSE of a friend list is the name of the friend,
2268    and its TREE_VALUE is another list.
2269
2270    For each element of that list, either the TREE_VALUE or the TREE_PURPOSE
2271    will be filled in, but not both.  The TREE_VALUE of that list is an
2272    individual function which is a friend.  The TREE_PURPOSE of that list
2273    indicates a type in which all functions by that name are friends.
2274
2275    Lists of friend classes come from _TYPE nodes.  Love that consistency
2276    thang.  */
2277
2278 int
2279 is_friend_type (type1, type2)
2280      tree type1, type2;
2281 {
2282   return is_friend (type1, type2);
2283 }
2284
2285 int
2286 is_friend (type, supplicant)
2287      tree type, supplicant;
2288 {
2289   int declp;
2290   register tree list;
2291
2292   if (supplicant == NULL_TREE || type == NULL_TREE)
2293     return 0;
2294
2295   declp = (TREE_CODE_CLASS (TREE_CODE (supplicant)) == 'd');
2296
2297   if (declp)
2298     /* It's a function decl.  */
2299     {
2300       tree list = DECL_FRIENDLIST (TYPE_NAME (type));
2301       tree name = DECL_NAME (supplicant);
2302       tree ctype;
2303
2304       if (DECL_FUNCTION_MEMBER_P (supplicant))
2305         ctype = DECL_CLASS_CONTEXT (supplicant);
2306       else
2307         ctype = NULL_TREE;
2308
2309       for (; list ; list = TREE_CHAIN (list))
2310         {
2311           if (name == TREE_PURPOSE (list))
2312             {
2313               tree friends = TREE_VALUE (list);
2314               name = DECL_ASSEMBLER_NAME (supplicant);
2315               for (; friends ; friends = TREE_CHAIN (friends))
2316                 {
2317                   if (ctype == TREE_PURPOSE (friends))
2318                     return 1;
2319                   if (name == DECL_ASSEMBLER_NAME (TREE_VALUE (friends)))
2320                     return 1;
2321                 }
2322               break;
2323             }
2324         }
2325     }
2326   else
2327     /* It's a type. */
2328     {
2329       if (type == supplicant)
2330         return 1;
2331
2332       list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_NAME (type)));
2333       for (; list ; list = TREE_CHAIN (list))
2334         if (supplicant == TREE_VALUE (list))
2335           return 1;
2336     }
2337
2338   {
2339     tree context;
2340
2341     if (! declp)
2342       context = DECL_CONTEXT (TYPE_NAME (supplicant));
2343     else if (DECL_FUNCTION_MEMBER_P (supplicant))
2344       context = DECL_CLASS_CONTEXT (supplicant);
2345     else
2346       context = NULL_TREE;
2347
2348     if (context)
2349       return is_friend (type, context);
2350   }
2351
2352   return 0;
2353 }
2354
2355 /* Add a new friend to the friends of the aggregate type TYPE.
2356    DECL is the FUNCTION_DECL of the friend being added.  */
2357 static void
2358 add_friend (type, decl)
2359      tree type, decl;
2360 {
2361   tree typedecl = TYPE_NAME (type);
2362   tree list = DECL_FRIENDLIST (typedecl);
2363   tree name = DECL_NAME (decl);
2364
2365   while (list)
2366     {
2367       if (name == TREE_PURPOSE (list))
2368         {
2369           tree friends = TREE_VALUE (list);
2370           for (; friends ; friends = TREE_CHAIN (friends))
2371             {
2372               if (decl == TREE_VALUE (friends))
2373                 {
2374                   cp_warning ("`%D' is already a friend of class `%T'",
2375                               decl, type);
2376                   cp_warning_at ("previous friend declaration of `%D'",
2377                                  TREE_VALUE (friends));
2378                   return;
2379                 }
2380             }
2381           TREE_VALUE (list) = tree_cons (error_mark_node, decl,
2382                                          TREE_VALUE (list));
2383           return;
2384         }
2385       list = TREE_CHAIN (list);
2386     }
2387   DECL_FRIENDLIST (typedecl)
2388     = tree_cons (DECL_NAME (decl), build_tree_list (error_mark_node, decl),
2389                  DECL_FRIENDLIST (typedecl));
2390   if (DECL_NAME (decl) == ansi_opname[(int) MODIFY_EXPR])
2391     {
2392       tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
2393       TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1;
2394       if (parmtypes && TREE_CHAIN (parmtypes))
2395         {
2396           tree parmtype = TREE_VALUE (TREE_CHAIN (parmtypes));
2397           if (TREE_CODE (parmtype) == REFERENCE_TYPE
2398               && TREE_TYPE (parmtypes) == TREE_TYPE (typedecl))
2399             TYPE_HAS_ASSIGN_REF (TREE_TYPE (typedecl)) = 1;
2400         }
2401     }
2402 }
2403
2404 /* Declare that every member function NAME in FRIEND_TYPE
2405    (which may be NULL_TREE) is a friend of type TYPE.  */
2406 static void
2407 add_friends (type, name, friend_type)
2408      tree type, name, friend_type;
2409 {
2410   tree typedecl = TYPE_NAME (type);
2411   tree list = DECL_FRIENDLIST (typedecl);
2412
2413   while (list)
2414     {
2415       if (name == TREE_PURPOSE (list))
2416         {
2417           tree friends = TREE_VALUE (list);
2418           while (friends && TREE_PURPOSE (friends) != friend_type)
2419             friends = TREE_CHAIN (friends);
2420           if (friends)
2421             if (friend_type)
2422               warning ("method `%s::%s' is already a friend of class",
2423                        TYPE_NAME_STRING (friend_type),
2424                        IDENTIFIER_POINTER (name));
2425             else
2426               warning ("function `%s' is already a friend of class `%s'",
2427                        IDENTIFIER_POINTER (name),
2428                        IDENTIFIER_POINTER (DECL_NAME (typedecl)));
2429           else
2430             TREE_VALUE (list) = tree_cons (friend_type, NULL_TREE,
2431                                            TREE_VALUE (list));
2432           return;
2433         }
2434       list = TREE_CHAIN (list);
2435     }
2436   DECL_FRIENDLIST (typedecl) =
2437     tree_cons (name,
2438                build_tree_list (friend_type, NULL_TREE),
2439                DECL_FRIENDLIST (typedecl));
2440   if (! strncmp (IDENTIFIER_POINTER (name),
2441                  IDENTIFIER_POINTER (ansi_opname[(int) MODIFY_EXPR]),
2442                  strlen (IDENTIFIER_POINTER (ansi_opname[(int) MODIFY_EXPR]))))
2443     {
2444       TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1;
2445       sorry ("declaring \"friend operator =\" will not find \"operator = (X&)\" if it exists");
2446     }
2447 }
2448
2449 /* Set up a cross reference so that type TYPE will make member function
2450    CTYPE::DECL a friend when CTYPE is finally defined.  For more than
2451    one, set up a cross reference so that functions with the name DECL
2452    and type CTYPE know that they are friends of TYPE.  */
2453 static void
2454 xref_friend (type, decl, ctype)
2455      tree type, decl, ctype;
2456 {
2457   tree friend_decl = TYPE_NAME (ctype);
2458 #if 0
2459   tree typedecl = TYPE_NAME (type);
2460   tree t = tree_cons (NULL_TREE, ctype, DECL_UNDEFINED_FRIENDS (typedecl));
2461
2462   DECL_UNDEFINED_FRIENDS (typedecl) = t;
2463 #else
2464   tree t = 0;
2465 #endif
2466   SET_DECL_WAITING_FRIENDS (friend_decl,
2467                             tree_cons (type, t,
2468                                        DECL_WAITING_FRIENDS (friend_decl)));
2469   TREE_TYPE (DECL_WAITING_FRIENDS (friend_decl)) = decl;
2470 }
2471
2472 /* Make FRIEND_TYPE a friend class to TYPE.  If FRIEND_TYPE has already
2473    been defined, we make all of its member functions friends of
2474    TYPE.  If not, we make it a pending friend, which can later be added
2475    when its definition is seen.  If a type is defined, then its TYPE_DECL's
2476    DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
2477    classes that are not defined.  If a type has not yet been defined,
2478    then the DECL_WAITING_FRIENDS contains a list of types
2479    waiting to make it their friend.  Note that these two can both
2480    be in use at the same time!  */
2481 void
2482 make_friend_class (type, friend_type)
2483      tree type, friend_type;
2484 {
2485   tree classes;
2486
2487   if (IS_SIGNATURE (type))
2488     {
2489       error ("`friend' declaration in signature definition");
2490       return;
2491     }
2492   if (IS_SIGNATURE (friend_type))
2493     {
2494       error ("signature type `%s' declared `friend'",
2495              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (friend_type))));
2496       return;
2497     }
2498   if (type == friend_type)
2499     {
2500       pedwarn ("class `%s' is implicitly friends with itself",
2501                TYPE_NAME_STRING (type));
2502       return;
2503     }
2504
2505   GNU_xref_hier (TYPE_NAME_STRING (type),
2506                  TYPE_NAME_STRING (friend_type), 0, 0, 1);
2507
2508   classes = CLASSTYPE_FRIEND_CLASSES (type);
2509   while (classes && TREE_VALUE (classes) != friend_type)
2510     classes = TREE_CHAIN (classes);
2511   if (classes)
2512     warning ("class `%s' is already friends with class `%s'",
2513              TYPE_NAME_STRING (TREE_VALUE (classes)), TYPE_NAME_STRING (type));
2514   else
2515     {
2516       CLASSTYPE_FRIEND_CLASSES (type)
2517         = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
2518     }
2519 }
2520
2521 /* Main friend processor.  This is large, and for modularity purposes,
2522    has been removed from grokdeclarator.  It returns `void_type_node'
2523    to indicate that something happened, though a FIELD_DECL is
2524    not returned.
2525
2526    CTYPE is the class this friend belongs to.
2527
2528    DECLARATOR is the name of the friend.
2529
2530    DECL is the FUNCTION_DECL that the friend is.
2531
2532    In case we are parsing a friend which is part of an inline
2533    definition, we will need to store PARM_DECL chain that comes
2534    with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL.
2535
2536    FLAGS is just used for `grokclassfn'.
2537
2538    QUALS say what special qualifies should apply to the object
2539    pointed to by `this'.  */
2540 tree
2541 do_friend (ctype, declarator, decl, parmdecls, flags, quals)
2542      tree ctype, declarator, decl, parmdecls;
2543      enum overload_flags flags;
2544      tree quals;
2545 {
2546   /* Every decl that gets here is a friend of something.  */
2547   DECL_FRIEND_P (decl) = 1;
2548
2549   if (ctype)
2550     {
2551       tree cname = TYPE_NAME (ctype);
2552       if (TREE_CODE (cname) == TYPE_DECL)
2553         cname = DECL_NAME (cname);
2554
2555       /* A method friend.  */
2556       if (TREE_CODE (decl) == FUNCTION_DECL)
2557         {
2558           if (flags == NO_SPECIAL && ctype && declarator == cname)
2559             DECL_CONSTRUCTOR_P (decl) = 1;
2560
2561           /* This will set up DECL_ARGUMENTS for us.  */
2562           grokclassfn (ctype, cname, decl, flags, quals);
2563           if (TYPE_SIZE (ctype) != 0)
2564             check_classfn (ctype, cname, decl);
2565
2566           if (TREE_TYPE (decl) != error_mark_node)
2567             {
2568               if (TYPE_SIZE (ctype))
2569                 {
2570                   /* We don't call pushdecl here yet, or ever on this
2571                      actual FUNCTION_DECL.  We must preserve its TREE_CHAIN
2572                      until the end.  */
2573                   make_decl_rtl (decl, NULL_PTR, 1);
2574                   add_friend (current_class_type, decl);
2575                 }
2576               else
2577                 {
2578                   register char *classname
2579                     = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (ctype)));
2580
2581                   error ("member declared as friend before type `%s' defined",
2582                          classname);
2583                 }
2584             }
2585         }
2586       else
2587         {
2588           /* Possibly a bunch of method friends.  */
2589
2590           /* Get the class they belong to.  */
2591           tree ctype = IDENTIFIER_TYPE_VALUE (cname);
2592
2593           /* This class is defined, use its methods now.  */
2594           if (TYPE_SIZE (ctype))
2595             {
2596               tree fields = lookup_fnfields (TYPE_BINFO (ctype), declarator, 0);
2597               if (fields)
2598                 add_friends (current_class_type, declarator, ctype);
2599               else
2600                 error ("method `%s' is not a member of class `%s'",
2601                        IDENTIFIER_POINTER (declarator),
2602                        IDENTIFIER_POINTER (cname));
2603             }
2604           else
2605             /* Note: DECLARATOR actually has more than one; in this
2606                case, we're making sure that fns with the name DECLARATOR
2607                and type CTYPE know they are friends of the current
2608                class type.  */
2609             xref_friend (current_class_type, declarator, ctype);
2610           decl = void_type_node;
2611         }
2612     }
2613   else if (TREE_CODE (decl) == FUNCTION_DECL
2614            && ((IDENTIFIER_LENGTH (declarator) == 4
2615                 && IDENTIFIER_POINTER (declarator)[0] == 'm'
2616                 && ! strcmp (IDENTIFIER_POINTER (declarator), "main"))
2617                || (IDENTIFIER_LENGTH (declarator) > 10
2618                    && IDENTIFIER_POINTER (declarator)[0] == '_'
2619                    && IDENTIFIER_POINTER (declarator)[1] == '_'
2620                    && strncmp (IDENTIFIER_POINTER (declarator)+2,
2621                                "builtin_", 8) == 0)))
2622     {
2623       /* raw "main", and builtin functions never gets overloaded,
2624          but they can become friends.  */
2625       add_friend (current_class_type, decl);
2626       DECL_FRIEND_P (decl) = 1;
2627       decl = void_type_node;
2628     }
2629   /* A global friend.
2630      @@ or possibly a friend from a base class ?!?  */
2631   else if (TREE_CODE (decl) == FUNCTION_DECL)
2632     {
2633       /* Friends must all go through the overload machinery,
2634          even though they may not technically be overloaded.
2635
2636          Note that because classes all wind up being top-level
2637          in their scope, their friend wind up in top-level scope as well.  */
2638       DECL_ASSEMBLER_NAME (decl)
2639         = build_decl_overload (declarator, TYPE_ARG_TYPES (TREE_TYPE (decl)),
2640                                TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
2641       DECL_ARGUMENTS (decl) = parmdecls;
2642       DECL_CLASS_CONTEXT (decl) = current_class_type;
2643
2644       /* We can call pushdecl here, because the TREE_CHAIN of this
2645          FUNCTION_DECL is not needed for other purposes.  */
2646       decl = pushdecl (decl);
2647
2648       make_decl_rtl (decl, NULL_PTR, 1);
2649       add_friend (current_class_type, decl);
2650
2651       DECL_FRIEND_P (decl) = 1;
2652 #if 0
2653       TREE_OVERLOADED (declarator) = 1;
2654 #endif
2655     }
2656   else
2657     {
2658       /* @@ Should be able to ingest later definitions of this function
2659          before use.  */
2660       tree decl = lookup_name_nonclass (declarator);
2661       if (decl == NULL_TREE)
2662         {
2663           warning ("implicitly declaring `%s' as struct",
2664                    IDENTIFIER_POINTER (declarator));
2665           decl = xref_tag (record_type_node, declarator, NULL_TREE, 1);
2666           decl = TYPE_NAME (decl);
2667         }
2668
2669       /* Allow abbreviated declarations of overloaded functions,
2670          but not if those functions are really class names.  */
2671       if (TREE_CODE (decl) == TREE_LIST && TREE_TYPE (TREE_PURPOSE (decl)))
2672         {
2673           warning ("`friend %s' archaic, use `friend class %s' instead",
2674                    IDENTIFIER_POINTER (declarator),
2675                    IDENTIFIER_POINTER (declarator));
2676           decl = TREE_TYPE (TREE_PURPOSE (decl));
2677         }
2678
2679       if (TREE_CODE (decl) == TREE_LIST)
2680         add_friends (current_class_type, TREE_PURPOSE (decl), NULL_TREE);
2681       else
2682         make_friend_class (current_class_type, TREE_TYPE (decl));
2683       decl = void_type_node;
2684     }
2685   return decl;
2686 }
2687
2688 /* TYPE has now been defined.  It may, however, have a number of things
2689    waiting make make it their friend.  We resolve these references
2690    here.  */
2691 void
2692 embrace_waiting_friends (type)
2693      tree type;
2694 {
2695   tree decl = TYPE_NAME (type);
2696   tree waiters;
2697
2698   if (TREE_CODE (decl) != TYPE_DECL)
2699     return;
2700
2701   for (waiters = DECL_WAITING_FRIENDS (decl); waiters;
2702        waiters = TREE_CHAIN (waiters))
2703     {
2704       tree waiter = TREE_PURPOSE (waiters);
2705 #if 0
2706       tree waiter_prev = TREE_VALUE (waiters);
2707 #endif
2708       tree decl = TREE_TYPE (waiters);
2709       tree name = decl ? (TREE_CODE (decl) == IDENTIFIER_NODE
2710                           ? decl : DECL_NAME (decl)) : NULL_TREE;
2711       if (name)
2712         {
2713           /* @@ There may be work to be done since we have not verified
2714              @@ consistency between original and friend declarations
2715              @@ of the functions waiting to become friends.  */
2716           tree field = lookup_fnfields (TYPE_BINFO (type), name, 0);
2717           if (field)
2718             if (decl == name)
2719               add_friends (waiter, name, type);
2720             else
2721               add_friend (waiter, decl);
2722           else
2723             error_with_file_and_line (DECL_SOURCE_FILE (TYPE_NAME (waiter)),
2724                                       DECL_SOURCE_LINE (TYPE_NAME (waiter)),
2725                                       "no method `%s' defined in class `%s' to be friend",
2726                                       IDENTIFIER_POINTER (DECL_NAME (TREE_TYPE (waiters))),
2727                                       TYPE_NAME_STRING (type));
2728         }
2729       else
2730         make_friend_class (type, waiter);
2731
2732 #if 0
2733       if (TREE_CHAIN (waiter_prev))
2734         TREE_CHAIN (waiter_prev) = TREE_CHAIN (TREE_CHAIN (waiter_prev));
2735       else
2736         DECL_UNDEFINED_FRIENDS (TYPE_NAME (waiter)) = NULL_TREE;
2737 #endif
2738     }
2739 }
2740 \f
2741 /* Common subroutines of build_new and build_vec_delete.  */
2742
2743 /* Common interface for calling "builtin" functions that are not
2744    really builtin.  */
2745
2746 tree
2747 build_builtin_call (type, node, arglist)
2748      tree type;
2749      tree node;
2750      tree arglist;
2751 {
2752   tree rval = build (CALL_EXPR, type, node, arglist, 0);
2753   TREE_SIDE_EFFECTS (rval) = 1;
2754   assemble_external (TREE_OPERAND (node, 0));
2755   TREE_USED (TREE_OPERAND (node, 0)) = 1;
2756   return rval;
2757 }
2758 \f
2759 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
2760    (which needs to go through some sort of groktypename) or it
2761    is the name of the class we are newing. INIT is an initialization value.
2762    It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
2763    If INIT is void_type_node, it means do *not* call a constructor
2764    for this instance.
2765
2766    For types with constructors, the data returned is initialized
2767    by the appropriate constructor.
2768
2769    Whether the type has a constructor or not, if it has a pointer
2770    to a virtual function table, then that pointer is set up
2771    here.
2772
2773    Unless I am mistaken, a call to new () will return initialized
2774    data regardless of whether the constructor itself is private or
2775    not.  NOPE; new fails if the constructor is private (jcm).
2776
2777    Note that build_new does nothing to assure that any special
2778    alignment requirements of the type are met.  Rather, it leaves
2779    it up to malloc to do the right thing.  Otherwise, folding to
2780    the right alignment cal cause problems if the user tries to later
2781    free the memory returned by `new'.
2782
2783    PLACEMENT is the `placement' list for user-defined operator new ().  */
2784
2785 extern int flag_check_new;
2786
2787 tree
2788 build_new (placement, decl, init, use_global_new)
2789      tree placement;
2790      tree decl, init;
2791      int use_global_new;
2792 {
2793   tree type, true_type, size, rval;
2794   tree nelts;
2795   tree alloc_expr, alloc_temp;
2796   int has_array = 0;
2797   enum tree_code code = NEW_EXPR;
2798
2799   tree pending_sizes = NULL_TREE;
2800
2801   if (decl == error_mark_node)
2802     return error_mark_node;
2803
2804   if (TREE_CODE (decl) == TREE_LIST)
2805     {
2806       tree absdcl = TREE_VALUE (decl);
2807       tree last_absdcl = NULL_TREE;
2808       int old_immediate_size_expand;
2809
2810       if (current_function_decl
2811           && DECL_CONSTRUCTOR_P (current_function_decl))
2812         {
2813           old_immediate_size_expand = immediate_size_expand;
2814           immediate_size_expand = 0;
2815         }
2816
2817       nelts = integer_one_node;
2818
2819       if (absdcl && TREE_CODE (absdcl) == CALL_EXPR)
2820         my_friendly_abort (215);
2821       while (absdcl && TREE_CODE (absdcl) == INDIRECT_REF)
2822         {
2823           last_absdcl = absdcl;
2824           absdcl = TREE_OPERAND (absdcl, 0);
2825         }
2826
2827       if (absdcl && TREE_CODE (absdcl) == ARRAY_REF)
2828         {
2829           /* probably meant to be a vec new */
2830           tree this_nelts;
2831
2832           while (TREE_OPERAND (absdcl, 0)
2833                  && TREE_CODE (TREE_OPERAND (absdcl, 0)) == ARRAY_REF)
2834             {
2835               last_absdcl = absdcl;
2836               absdcl = TREE_OPERAND (absdcl, 0);
2837             }
2838
2839           has_array = 1;
2840           this_nelts = TREE_OPERAND (absdcl, 1);
2841           if (this_nelts != error_mark_node)
2842             {
2843               if (this_nelts == NULL_TREE)
2844                 error ("new of array type fails to specify size");
2845               else
2846                 {
2847                   this_nelts = save_expr (convert (sizetype, this_nelts));
2848                   absdcl = TREE_OPERAND (absdcl, 0);
2849                   if (this_nelts == integer_zero_node)
2850                     {
2851                       warning ("zero size array reserves no space");
2852                       nelts = integer_zero_node;
2853                     }
2854                   else
2855                     nelts = build_binary_op (MULT_EXPR, nelts, this_nelts, 1);
2856                 }
2857             }
2858           else
2859             nelts = integer_zero_node;
2860         }
2861
2862       if (last_absdcl)
2863         TREE_OPERAND (last_absdcl, 0) = absdcl;
2864       else
2865         TREE_VALUE (decl) = absdcl;
2866
2867       type = true_type = groktypename (decl);
2868       if (! type || type == error_mark_node)
2869         {
2870           immediate_size_expand = old_immediate_size_expand;
2871           return error_mark_node;
2872         }
2873
2874       if (current_function_decl
2875           && DECL_CONSTRUCTOR_P (current_function_decl))
2876         {
2877           pending_sizes = get_pending_sizes ();
2878           immediate_size_expand = old_immediate_size_expand;
2879         }
2880     }
2881   else if (TREE_CODE (decl) == IDENTIFIER_NODE)
2882     {
2883       if (IDENTIFIER_HAS_TYPE_VALUE (decl))
2884         {
2885           /* An aggregate type.  */
2886           type = IDENTIFIER_TYPE_VALUE (decl);
2887           decl = TYPE_NAME (type);
2888         }
2889       else
2890         {
2891           /* A builtin type.  */
2892           decl = lookup_name (decl, 1);
2893           my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 215);
2894           type = TREE_TYPE (decl);
2895         }
2896       true_type = type;
2897     }
2898   else if (TREE_CODE (decl) == TYPE_DECL)
2899     {
2900       type = TREE_TYPE (decl);
2901       true_type = type;
2902     }
2903   else
2904     {
2905       type = decl;
2906       true_type = type;
2907       decl = TYPE_NAME (type);
2908     }
2909
2910   /* ``A reference cannot be created by the new operator.  A reference
2911      is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2912      returned by new.'' ARM 5.3.3 */
2913   if (TREE_CODE (type) == REFERENCE_TYPE)
2914     {
2915       error ("new cannot be applied to a reference type");
2916       type = true_type = TREE_TYPE (type);
2917     }
2918
2919   if (TREE_CODE (type) == FUNCTION_TYPE)
2920     {
2921       error ("new cannot be applied to a function type");
2922       return error_mark_node;
2923     }
2924
2925   /* When the object being created is an array, the new-expression yields a
2926      pointer to the initial element (if any) of the array.  For example,
2927      both new int and new int[10] return an int*.  5.3.4.  */
2928   if (TREE_CODE (type) == ARRAY_TYPE && has_array == 0)
2929     {
2930       nelts = array_type_nelts_top (type);
2931       has_array = 1;
2932       type = true_type = TREE_TYPE (type);
2933     }
2934
2935   if (TYPE_READONLY (type) || TYPE_VOLATILE (type))
2936     type = TYPE_MAIN_VARIANT (type);
2937
2938   /* If our base type is an array, then make sure we know how many elements
2939      it has.  */
2940   while (TREE_CODE (true_type) == ARRAY_TYPE)
2941     {
2942       tree this_nelts = array_type_nelts_top (true_type);
2943       nelts = build_binary_op (MULT_EXPR, nelts, this_nelts, 1);
2944       true_type = TREE_TYPE (true_type);
2945     }
2946   if (has_array)
2947     size = fold (build_binary_op (MULT_EXPR, size_in_bytes (true_type),
2948                                   nelts, 1));
2949   else
2950     size = size_in_bytes (type);
2951
2952   if (true_type == void_type_node)
2953     {
2954       error ("invalid type `void' for new");
2955       return error_mark_node;
2956     }
2957
2958   if (TYPE_SIZE (true_type) == 0)
2959     {
2960       incomplete_type_error (0, true_type);
2961       return error_mark_node;
2962     }
2963
2964   if (TYPE_LANG_SPECIFIC (true_type)
2965       && CLASSTYPE_ABSTRACT_VIRTUALS (true_type))
2966     {
2967       abstract_virtuals_error (NULL_TREE, true_type);
2968       return error_mark_node;
2969     }
2970
2971   if (TYPE_LANG_SPECIFIC (true_type) && IS_SIGNATURE (true_type))
2972     {
2973       signature_error (NULL_TREE, true_type);
2974       return error_mark_node;
2975     }
2976
2977   /* Get a little extra space to store a couple of things before the new'ed
2978      array. */
2979   if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type))
2980     {
2981       tree extra = BI_header_size;
2982
2983       size = size_binop (PLUS_EXPR, size, extra);
2984     }
2985
2986   if (has_array)
2987     code = VEC_NEW_EXPR;
2988
2989   /* Allocate the object. */
2990   if (! use_global_new && TYPE_LANG_SPECIFIC (true_type)
2991       && (TYPE_GETS_NEW (true_type) & (1 << has_array)))
2992     rval = build_opfncall (code, LOOKUP_NORMAL,
2993                            TYPE_POINTER_TO (true_type), size, placement);
2994   else if (placement)
2995     {
2996       rval = build_opfncall (code, LOOKUP_GLOBAL|LOOKUP_COMPLAIN,
2997                              ptr_type_node, size, placement);
2998       rval = convert (TYPE_POINTER_TO (true_type), rval);
2999     }
3000   else if (! has_array && flag_this_is_variable > 0
3001            && TYPE_NEEDS_CONSTRUCTING (true_type) && init != void_type_node)
3002     {
3003       if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST)
3004         rval = NULL_TREE;
3005       else
3006         {
3007           error ("constructors take parameter lists");
3008           return error_mark_node;
3009         }
3010     }
3011   else
3012     {
3013       rval = build_builtin_call (build_pointer_type (true_type),
3014                                  has_array ? BIVN : BIN,
3015                                  build_tree_list (NULL_TREE, size));
3016 #if 0
3017       /* See comment above as to why this is disabled.  */
3018       if (alignment)
3019         {
3020           rval = build (PLUS_EXPR, TYPE_POINTER_TO (true_type), rval,
3021                         alignment);
3022           rval = build (BIT_AND_EXPR, TYPE_POINTER_TO (true_type),
3023                         rval, build1 (BIT_NOT_EXPR, integer_type_node,
3024                                       alignment));
3025         }
3026 #endif
3027       TREE_CALLS_NEW (rval) = 1;
3028     }
3029
3030   if (flag_check_new && rval)
3031     {
3032       /* For array new, we need to make sure that the call to new is
3033          not expanded as part of the RTL_EXPR for the initialization,
3034          so we can't just use save_expr here.  */
3035
3036       alloc_temp = get_temp_name (TREE_TYPE (rval), 0);
3037       alloc_expr = build (MODIFY_EXPR, TREE_TYPE (rval), alloc_temp, rval);
3038       TREE_SIDE_EFFECTS (alloc_expr) = 1;
3039       rval = alloc_temp;
3040     }
3041   else
3042     alloc_expr = NULL_TREE;
3043
3044   /* if rval is NULL_TREE I don't have to allocate it, but are we totally
3045      sure we have some extra bytes in that case for the BI_header_size
3046      cookies? And how does that interact with the code below? (mrs) */
3047   /* Finish up some magic for new'ed arrays */
3048   if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type) && rval != NULL_TREE)
3049     {
3050       tree extra = BI_header_size;
3051       tree cookie, exp1;
3052       rval = convert (ptr_type_node, rval);    /* convert to void * first */
3053       rval = convert (string_type_node, rval); /* lets not add void* and ints */
3054       rval = save_expr (build_binary_op (PLUS_EXPR, rval, extra, 1));
3055       /* Store header info.  */
3056       cookie = build_indirect_ref (build (MINUS_EXPR, TYPE_POINTER_TO (BI_header_type),
3057                                           rval, extra), NULL_PTR);
3058       exp1 = build (MODIFY_EXPR, void_type_node,
3059                     build_component_ref (cookie, nc_nelts_field_id, 0, 0),
3060                     nelts);
3061       TREE_SIDE_EFFECTS (exp1) = 1;
3062       rval = convert (build_pointer_type (true_type), rval);
3063       TREE_CALLS_NEW (rval) = 1;
3064       TREE_SIDE_EFFECTS (rval) = 1;
3065       rval = build_compound_expr (tree_cons (NULL_TREE, exp1,
3066                                              build_tree_list (NULL_TREE, rval)));
3067     }
3068
3069   if (rval == error_mark_node)
3070     return error_mark_node;
3071
3072   /* Don't call any constructors or do any initialization.  */
3073   if (init == void_type_node)
3074     goto done;
3075
3076   if (TYPE_NEEDS_CONSTRUCTING (type) || init)
3077     {
3078       if (! TYPE_NEEDS_CONSTRUCTING (type) && ! IS_AGGR_TYPE (type))
3079         {
3080           /* New 2.0 interpretation: `new int (10)' means
3081              allocate an int, and initialize it with 10.  */
3082           tree deref;
3083
3084           rval = save_expr (rval);
3085           deref = build_indirect_ref (rval, NULL_PTR);
3086           TREE_READONLY (deref) = 0;
3087
3088           if (TREE_CHAIN (init) != NULL_TREE)
3089             pedwarn ("initializer list being treated as compound expression");
3090           init = build_compound_expr (init);
3091
3092           init = convert_for_initialization (deref, type, init, LOOKUP_NORMAL,
3093                                              "new", NULL_TREE, 0);
3094           rval = build (COMPOUND_EXPR, TREE_TYPE (rval),
3095                         build_modify_expr (deref, NOP_EXPR, init),
3096                         rval);
3097           TREE_NO_UNUSED_WARNING (rval) = 1;
3098           TREE_SIDE_EFFECTS (rval) = 1;
3099           TREE_CALLS_NEW (rval) = 1;
3100         }
3101       else if (! has_array)
3102         {
3103           tree newrval;
3104           /* Constructors are never virtual. If it has an initialization, we
3105              need to complain if we aren't allowed to use the ctor that took
3106              that argument.  */
3107           int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_COMPLAIN;
3108
3109           if (rval && TYPE_USES_VIRTUAL_BASECLASSES (true_type))
3110             {
3111               init = tree_cons (NULL_TREE, integer_one_node, init);
3112               flags |= LOOKUP_HAS_IN_CHARGE;
3113             }
3114
3115           newrval = rval;
3116
3117           if (newrval && TREE_CODE (TREE_TYPE (newrval)) == POINTER_TYPE)
3118             newrval = build_indirect_ref (newrval, NULL_PTR);
3119
3120           newrval = build_method_call (newrval, constructor_name_full (true_type),
3121                                        init, NULL_TREE, flags);
3122
3123           if (newrval)
3124             {
3125               rval = newrval;
3126               TREE_HAS_CONSTRUCTOR (rval) = 1;
3127             }
3128           else
3129             rval = error_mark_node;
3130         }
3131       else if (current_function_decl == NULL_TREE)
3132         {
3133           extern tree static_aggregates;
3134
3135           /* In case of static initialization, SAVE_EXPR is good enough.  */
3136           rval = save_expr (rval);
3137           init = copy_to_permanent (init);
3138           rval = copy_to_permanent (rval);
3139           static_aggregates = perm_tree_cons (init, rval, static_aggregates);
3140         }
3141       else
3142         {
3143           /* Have to wrap this in RTL_EXPR for two cases:
3144              in base or member initialization and if we
3145              are a branch of a ?: operator.  Since we
3146              can't easily know the latter, just do it always.  */
3147           tree xval = make_node (RTL_EXPR);
3148
3149           TREE_TYPE (xval) = TREE_TYPE (rval);
3150           do_pending_stack_adjust ();
3151           start_sequence_for_rtl_expr (xval);
3152
3153           /* As a matter of principle, `start_sequence' should do this.  */
3154           emit_note (0, -1);
3155
3156           rval = save_expr (rval);
3157           rval = expand_vec_init (decl, rval,
3158                                   build_binary_op (MINUS_EXPR, nelts,
3159                                                    integer_one_node, 1),
3160                                   init, 0);
3161
3162           do_pending_stack_adjust ();
3163
3164           TREE_SIDE_EFFECTS (xval) = 1;
3165           TREE_CALLS_NEW (xval) = 1;
3166           RTL_EXPR_SEQUENCE (xval) = get_insns ();
3167           end_sequence ();
3168
3169           if (TREE_CODE (rval) == SAVE_EXPR)
3170             {
3171               /* Errors may cause this to not get evaluated.  */
3172               if (SAVE_EXPR_RTL (rval) == 0)
3173                 SAVE_EXPR_RTL (rval) = const0_rtx;
3174               RTL_EXPR_RTL (xval) = SAVE_EXPR_RTL (rval);
3175             }
3176           else
3177             {
3178               my_friendly_assert (TREE_CODE (rval) == VAR_DECL, 217);
3179               RTL_EXPR_RTL (xval) = DECL_RTL (rval);
3180             }
3181           rval = xval;
3182         }
3183     }
3184   else if (TYPE_READONLY (true_type))
3185     cp_error ("uninitialized const in `new' of `%#T'", true_type);
3186
3187  done:
3188
3189   if (alloc_expr)
3190     {
3191       /* Did we modify the storage?  */
3192       if (rval != alloc_temp)
3193         {
3194           tree ifexp = build_binary_op (NE_EXPR, alloc_expr,
3195                                         integer_zero_node, 1);
3196           rval = build_conditional_expr (ifexp, rval, alloc_temp);
3197         }
3198       else
3199         rval = alloc_expr;
3200     }
3201
3202   if (rval && TREE_TYPE (rval) != build_pointer_type (type))
3203     {
3204       /* The type of new int [3][3] is not int *, but int [3] * */
3205       rval = build_c_cast (build_pointer_type (type), rval, 0);
3206     }
3207
3208   if (pending_sizes)
3209     rval = build_compound_expr (chainon (pending_sizes,
3210                                          build_tree_list (NULL_TREE, rval)));
3211
3212   if (flag_gc)
3213     {
3214       extern tree gc_visible;
3215       tree objbits;
3216       tree update_expr;
3217
3218       rval = save_expr (rval);
3219       /* We don't need a `headof' operation to do this because
3220          we know where the object starts.  */
3221       objbits = build1 (INDIRECT_REF, unsigned_type_node,
3222                         build (MINUS_EXPR, ptr_type_node,
3223                                rval, c_sizeof_nowarn (unsigned_type_node)));
3224       update_expr = build_modify_expr (objbits, BIT_IOR_EXPR, gc_visible);
3225       rval = build_compound_expr (tree_cons (NULL_TREE, rval,
3226                                              tree_cons (NULL_TREE, update_expr,
3227                                                         build_tree_list (NULL_TREE, rval))));
3228     }
3229
3230   return rval;
3231 }
3232 \f
3233 /* `expand_vec_init' performs initialization of a vector of aggregate
3234    types.
3235
3236    DECL is passed only for error reporting, and provides line number
3237    and source file name information.
3238    BASE is the space where the vector will be.
3239    MAXINDEX is the maximum index of the array (one less than the
3240             number of elements).
3241    INIT is the (possibly NULL) initializer.
3242
3243    FROM_ARRAY is 0 if we should init everything with INIT
3244    (i.e., every element initialized from INIT).
3245    FROM_ARRAY is 1 if we should index into INIT in parallel
3246    with initialization of DECL.
3247    FROM_ARRAY is 2 if we should index into INIT in parallel,
3248    but use assignment instead of initialization.  */
3249
3250 tree
3251 expand_vec_init (decl, base, maxindex, init, from_array)
3252      tree decl, base, maxindex, init;
3253      int from_array;
3254 {
3255   tree rval;
3256   tree iterator, base2 = NULL_TREE;
3257   tree type = TREE_TYPE (TREE_TYPE (base));
3258   tree size;
3259
3260   maxindex = convert (integer_type_node, maxindex);
3261   if (maxindex == error_mark_node)
3262     return error_mark_node;
3263
3264   if (current_function_decl == NULL_TREE)
3265     {
3266       rval = make_tree_vec (3);
3267       TREE_VEC_ELT (rval, 0) = base;
3268       TREE_VEC_ELT (rval, 1) = maxindex;
3269       TREE_VEC_ELT (rval, 2) = init;
3270       return rval;
3271     }
3272
3273   size = size_in_bytes (type);
3274
3275   /* Set to zero in case size is <= 0.  Optimizer will delete this if
3276      it is not needed.  */
3277   rval = get_temp_regvar (TYPE_POINTER_TO (type),
3278                           convert (TYPE_POINTER_TO (type), null_pointer_node));
3279   base = default_conversion (base);
3280   base = convert (TYPE_POINTER_TO (type), base);
3281   expand_assignment (rval, base, 0, 0);
3282   base = get_temp_regvar (TYPE_POINTER_TO (type), base);
3283
3284   if (init != NULL_TREE
3285       && TREE_CODE (init) == CONSTRUCTOR
3286       && TREE_TYPE (init) == TREE_TYPE (decl))
3287     {
3288       /* Initialization of array from {...}.  */
3289       tree elts = CONSTRUCTOR_ELTS (init);
3290       tree baseref = build1 (INDIRECT_REF, type, base);
3291       tree baseinc = build (PLUS_EXPR, TYPE_POINTER_TO (type), base, size);
3292       int host_i = TREE_INT_CST_LOW (maxindex);
3293
3294       if (IS_AGGR_TYPE (type))
3295         {
3296           while (elts)
3297             {
3298               host_i -= 1;
3299               expand_aggr_init (baseref, TREE_VALUE (elts), 0, 0);
3300
3301               expand_assignment (base, baseinc, 0, 0);
3302               elts = TREE_CHAIN (elts);
3303             }
3304           /* Initialize any elements by default if possible.  */
3305           if (host_i >= 0)
3306             {
3307               if (TYPE_NEEDS_CONSTRUCTING (type) == 0)
3308                 {
3309                   if (obey_regdecls)
3310                     use_variable (DECL_RTL (base));
3311                   goto done_init;
3312                 }
3313
3314               iterator = get_temp_regvar (integer_type_node,
3315                                           build_int_2 (host_i, 0));
3316               init = NULL_TREE;
3317               goto init_by_default;
3318             }
3319         }
3320       else
3321         while (elts)
3322           {
3323             expand_assignment (baseref, TREE_VALUE (elts), 0, 0);
3324
3325             expand_assignment (base, baseinc, 0, 0);
3326             elts = TREE_CHAIN (elts);
3327           }
3328
3329       if (obey_regdecls)
3330         use_variable (DECL_RTL (base));
3331     }
3332   else
3333     {
3334       tree itype;
3335
3336       iterator = get_temp_regvar (integer_type_node, maxindex);
3337
3338     init_by_default:
3339
3340       /* If initializing one array from another,
3341          initialize element by element.  */
3342       if (from_array)
3343         {
3344           /* We rely upon the below calls the do argument checking */
3345           if (decl == NULL_TREE)
3346             {
3347               sorry ("initialization of array from dissimilar array type");
3348               return error_mark_node;
3349             }
3350           if (init)
3351             {
3352               base2 = default_conversion (init);
3353               itype = TREE_TYPE (base2);
3354               base2 = get_temp_regvar (itype, base2);
3355               itype = TREE_TYPE (itype);
3356             }
3357           else if (TYPE_LANG_SPECIFIC (type)
3358                    && TYPE_NEEDS_CONSTRUCTING (type)
3359                    && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
3360             {
3361               error ("initializer ends prematurely");
3362               return error_mark_node;
3363             }
3364         }
3365
3366       expand_start_cond (build (GE_EXPR, boolean_type_node,
3367                                 iterator, integer_zero_node), 0);
3368       expand_start_loop_continue_elsewhere (1);
3369
3370       if (from_array)
3371         {
3372           tree to = build1 (INDIRECT_REF, type, base);
3373           tree from;
3374
3375           if (base2)
3376             from = build1 (INDIRECT_REF, itype, base2);
3377           else
3378             from = NULL_TREE;
3379
3380           if (from_array == 2)
3381             expand_expr_stmt (build_modify_expr (to, NOP_EXPR, from));
3382           else if (TYPE_NEEDS_CONSTRUCTING (type))
3383             expand_aggr_init (to, from, 0, 0);
3384           else if (from)
3385             expand_assignment (to, from, 0, 0);
3386           else
3387             my_friendly_abort (57);
3388         }
3389       else if (TREE_CODE (type) == ARRAY_TYPE)
3390         {
3391           if (init != 0)
3392             sorry ("cannot initialize multi-dimensional array with initializer");
3393           expand_vec_init (decl, build1 (NOP_EXPR, TYPE_POINTER_TO (TREE_TYPE (type)), base),
3394                            array_type_nelts (type), 0, 0);
3395         }
3396       else
3397         expand_aggr_init (build1 (INDIRECT_REF, type, base), init, 0, 0);
3398
3399       expand_assignment (base,
3400                          build (PLUS_EXPR, TYPE_POINTER_TO (type), base, size),
3401                          0, 0);
3402       if (base2)
3403         expand_assignment (base2,
3404                            build (PLUS_EXPR, TYPE_POINTER_TO (type), base2, size), 0, 0);
3405       expand_loop_continue_here ();
3406       expand_exit_loop_if_false (0, build (NE_EXPR, boolean_type_node,
3407                                            build (PREDECREMENT_EXPR, integer_type_node, iterator, integer_one_node), minus_one));
3408
3409       if (obey_regdecls)
3410         {
3411           use_variable (DECL_RTL (base));
3412           if (base2)
3413             use_variable (DECL_RTL (base2));
3414         }
3415       expand_end_loop ();
3416       expand_end_cond ();
3417       if (obey_regdecls)
3418         use_variable (DECL_RTL (iterator));
3419     }
3420  done_init:
3421
3422   if (obey_regdecls)
3423     use_variable (DECL_RTL (rval));
3424   return rval;
3425 }
3426
3427 /* Free up storage of type TYPE, at address ADDR.
3428
3429    TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3430    of pointer.
3431
3432    VIRTUAL_SIZE is the amount of storage that was allocated, and is
3433    used as the second argument to operator delete.  It can include
3434    things like padding and magic size cookies.  It has virtual in it,
3435    because if you have a base pointer and you delete through a virtual
3436    destructor, it should be the size of the dynamic object, not the
3437    static object, see Free Store 12.5 ANSI C++ WP.
3438
3439    This does not call any destructors.  */
3440 tree
3441 build_x_delete (type, addr, which_delete, virtual_size)
3442      tree type, addr;
3443      int which_delete;
3444      tree virtual_size;
3445 {
3446   int use_global_delete = which_delete & 1;
3447   int use_vec_delete = !!(which_delete & 2);
3448   tree rval;
3449   enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
3450
3451   if (! use_global_delete && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
3452       && (TYPE_GETS_DELETE (TREE_TYPE (type)) & (1 << use_vec_delete)))
3453     rval = build_opfncall (code, LOOKUP_NORMAL, addr, virtual_size, NULL_TREE);
3454   else
3455     rval = build_builtin_call (void_type_node, use_vec_delete ? BIVD : BID,
3456                                build_tree_list (NULL_TREE, addr));
3457   return rval;
3458 }
3459
3460 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3461    ADDR is an expression which yields the store to be destroyed.
3462    AUTO_DELETE is nonzero if a call to DELETE should be made or not.
3463    If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
3464    virtual baseclasses.
3465    If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
3466
3467    FLAGS is the logical disjunction of zero or more LOOKUP_
3468    flags.  See cp-tree.h for more info.
3469
3470    This function does not delete an object's virtual base classes.  */
3471 tree
3472 build_delete (type, addr, auto_delete, flags, use_global_delete)
3473      tree type, addr;
3474      tree auto_delete;
3475      int flags;
3476      int use_global_delete;
3477 {
3478   tree function, parms;
3479   tree member;
3480   tree expr;
3481   tree ref;
3482   int ptr;
3483
3484   if (addr == error_mark_node)
3485     return error_mark_node;
3486
3487   /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3488      set to `error_mark_node' before it gets properly cleaned up.  */
3489   if (type == error_mark_node)
3490     return error_mark_node;
3491
3492   type = TYPE_MAIN_VARIANT (type);
3493
3494   if (TREE_CODE (type) == POINTER_TYPE)
3495     {
3496       type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3497       if (TYPE_SIZE (type) == 0)
3498         {
3499           incomplete_type_error (0, type);
3500           return error_mark_node;
3501         }
3502       if (TREE_CODE (type) == ARRAY_TYPE)
3503         goto handle_array;
3504       if (! IS_AGGR_TYPE (type))
3505         {
3506           /* Call the builtin operator delete.  */
3507           return build_builtin_call (void_type_node, BID,
3508                                      build_tree_list (NULL_TREE, addr));
3509         }
3510       if (TREE_SIDE_EFFECTS (addr))
3511         addr = save_expr (addr);
3512
3513       /* throw away const and volatile on target type of addr */
3514       addr = convert_force (build_pointer_type (type), addr, 0);
3515       ref = build_indirect_ref (addr, NULL_PTR);
3516       ptr = 1;
3517     }
3518   else if (TREE_CODE (type) == ARRAY_TYPE)
3519     {
3520     handle_array:
3521       if (TREE_SIDE_EFFECTS (addr))
3522         addr = save_expr (addr);
3523       return build_vec_delete (addr, array_type_nelts (type),
3524                                c_sizeof_nowarn (TREE_TYPE (type)),
3525                                auto_delete, integer_two_node,
3526                                use_global_delete);
3527     }
3528   else
3529     {
3530       /* Don't check PROTECT here; leave that decision to the
3531          destructor.  If the destructor is accessible, call it,
3532          else report error.  */
3533       addr = build_unary_op (ADDR_EXPR, addr, 0);
3534       if (TREE_SIDE_EFFECTS (addr))
3535         addr = save_expr (addr);
3536
3537       if (TREE_CONSTANT (addr))
3538         addr = convert_pointer_to (type, addr);
3539       else
3540         addr = convert_force (build_pointer_type (type), addr, 0);
3541
3542       if (TREE_CODE (addr) == NOP_EXPR
3543           && TREE_OPERAND (addr, 0) == current_class_decl)
3544         ref = C_C_D;
3545       else
3546         ref = build_indirect_ref (addr, NULL_PTR);
3547       ptr = 0;
3548     }
3549
3550   my_friendly_assert (IS_AGGR_TYPE (type), 220);
3551
3552   if (! TYPE_NEEDS_DESTRUCTOR (type))
3553     {
3554       if (auto_delete == integer_zero_node)
3555         return void_zero_node;
3556
3557       /* Pass the size of the object down to the operator delete() in
3558          addition to the ADDR.  */
3559       if (TYPE_GETS_REG_DELETE (type) && !use_global_delete)
3560         {
3561           tree virtual_size = c_sizeof_nowarn (type);
3562           return build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, addr,
3563                                  virtual_size, NULL_TREE);
3564         }
3565
3566       /* Call the builtin operator delete.  */
3567       return build_builtin_call (void_type_node, BID,
3568                                  build_tree_list (NULL_TREE, addr));
3569     }
3570   parms = build_tree_list (NULL_TREE, addr);
3571
3572   /* Below, we will reverse the order in which these calls are made.
3573      If we have a destructor, then that destructor will take care
3574      of the base classes; otherwise, we must do that here.  */
3575   if (TYPE_HAS_DESTRUCTOR (type))
3576     {
3577       tree dtor = DECL_MAIN_VARIANT (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0));
3578       tree basetypes = TYPE_BINFO (type);
3579       tree passed_auto_delete;
3580       tree do_delete = NULL_TREE;
3581
3582       if (use_global_delete)
3583         {
3584           tree cond = fold (build (BIT_AND_EXPR, integer_type_node,
3585                                    auto_delete, integer_one_node));
3586           tree call = build_builtin_call
3587             (void_type_node, BID, build_tree_list (NULL_TREE, addr));
3588
3589           cond = fold (build (COND_EXPR, void_type_node, cond,
3590                               call, void_zero_node));
3591           if (cond != void_zero_node)
3592             do_delete = cond;
3593
3594           passed_auto_delete = fold (build (BIT_AND_EXPR, integer_type_node,
3595                                             auto_delete, integer_two_node));
3596         }
3597       else
3598         {
3599           if (TYPE_GETS_REG_DELETE (type))
3600             {
3601               /* Only do access checking here; we'll be calling op delete
3602                  from the destructor.  */
3603               tree t = build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, addr,
3604                                        size_zero_node, NULL_TREE);
3605               if (t == error_mark_node)
3606                 return error_mark_node;
3607             }
3608           passed_auto_delete = auto_delete;
3609         }
3610
3611       if (flags & LOOKUP_PROTECT)
3612         {
3613           enum access_type access = compute_access (basetypes, dtor);
3614
3615           if (access == access_private)
3616             {
3617               if (flags & LOOKUP_COMPLAIN)
3618                 cp_error ("destructor for type `%T' is private in this scope", type);
3619               return error_mark_node;
3620             }
3621           else if (access == access_protected)
3622             {
3623               if (flags & LOOKUP_COMPLAIN)
3624                 cp_error ("destructor for type `%T' is protected in this scope", type);
3625               return error_mark_node;
3626             }
3627         }
3628
3629       /* Once we are in a destructor, try not going through
3630          the virtual function table to find the next destructor.  */
3631       if (DECL_VINDEX (dtor)
3632           && ! (flags & LOOKUP_NONVIRTUAL)
3633           && TREE_CODE (auto_delete) != PARM_DECL
3634           && (ptr == 1 || ! resolves_to_fixed_type_p (ref, 0)))
3635         {
3636           tree binfo, basetype;
3637           /* The code below is probably all broken.  See call.c for the
3638              complete right way to do this. this offsets may not be right
3639              in the below.  (mrs) */
3640           /* This destructor must be called via virtual function table.  */
3641           dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (DECL_CONTEXT (dtor)), 0);
3642           basetype = DECL_CLASS_CONTEXT (dtor);
3643           binfo = get_binfo (basetype,
3644                              TREE_TYPE (TREE_TYPE (TREE_VALUE (parms))),
3645                              0);
3646           expr = convert_pointer_to_real (binfo, TREE_VALUE (parms));
3647           if (expr != TREE_VALUE (parms))
3648             {
3649               expr = fold (expr);
3650               ref = build_indirect_ref (expr, NULL_PTR);
3651               TREE_VALUE (parms) = expr;
3652             }
3653           function = build_vfn_ref (&TREE_VALUE (parms), ref, DECL_VINDEX (dtor));
3654           if (function == error_mark_node)
3655             return error_mark_node;
3656           TREE_TYPE (function) = build_pointer_type (TREE_TYPE (dtor));
3657           TREE_CHAIN (parms) = build_tree_list (NULL_TREE, passed_auto_delete);
3658           expr = build_function_call (function, parms);
3659           if (do_delete)
3660             expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete);
3661           if (ptr && (flags & LOOKUP_DESTRUCTOR) == 0)
3662             {
3663               /* Handle the case where a virtual destructor is
3664                  being called on an item that is 0.
3665
3666                  @@ Does this really need to be done?  */
3667               tree ifexp = build_binary_op(NE_EXPR, addr, integer_zero_node,1);
3668 #if 0
3669               if (TREE_CODE (ref) == VAR_DECL
3670                   || TREE_CODE (ref) == COMPONENT_REF)
3671                 warning ("losing in build_delete");
3672 #endif
3673               expr = build (COND_EXPR, void_type_node,
3674                             ifexp, expr, void_zero_node);
3675             }
3676         }
3677       else
3678         {
3679           tree ifexp;
3680
3681           if ((flags & LOOKUP_DESTRUCTOR)
3682               || TREE_CODE (ref) == VAR_DECL
3683               || TREE_CODE (ref) == PARM_DECL
3684               || TREE_CODE (ref) == COMPONENT_REF
3685               || TREE_CODE (ref) == ARRAY_REF)
3686             /* These can't be 0.  */
3687             ifexp = integer_one_node;
3688           else
3689             /* Handle the case where a non-virtual destructor is
3690                being called on an item that is 0.  */
3691             ifexp = build_binary_op (NE_EXPR, addr, integer_zero_node, 1);
3692
3693           /* Used to mean that this destructor was known to be empty,
3694              but that's now obsolete.  */
3695           my_friendly_assert (DECL_INITIAL (dtor) != void_type_node, 221);
3696
3697           TREE_CHAIN (parms) = build_tree_list (NULL_TREE, passed_auto_delete);
3698           expr = build_function_call (dtor, parms);
3699           if (do_delete)
3700             expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete);
3701
3702           if (ifexp != integer_one_node)
3703             expr = build (COND_EXPR, void_type_node,
3704                           ifexp, expr, void_zero_node);
3705         }
3706       return expr;
3707     }
3708   else
3709     {
3710       /* This can get visibilities wrong.  */
3711       tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
3712       int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
3713       tree base_binfo = n_baseclasses > 0 ? TREE_VEC_ELT (binfos, 0) : NULL_TREE;
3714       tree exprstmt = NULL_TREE;
3715       tree parent_auto_delete = auto_delete;
3716       tree cond;
3717
3718       /* If this type does not have a destructor, but does have
3719          operator delete, call the parent parent destructor (if any),
3720          but let this node do the deleting.  Otherwise, it is ok
3721          to let the parent destructor do the deleting.  */
3722       if (TYPE_GETS_REG_DELETE (type) && !use_global_delete)
3723         {
3724           parent_auto_delete = integer_zero_node;
3725           if (auto_delete == integer_zero_node)
3726             cond = NULL_TREE;
3727           else
3728             {
3729               tree virtual_size;
3730
3731                 /* This is probably wrong. It should be the size of the
3732                    virtual object being deleted.  */
3733               virtual_size = c_sizeof_nowarn (type);
3734
3735               expr = build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, addr,
3736                                      virtual_size, NULL_TREE);
3737               if (expr == error_mark_node)
3738                 return error_mark_node;
3739               if (auto_delete != integer_one_node)
3740                 cond = build (COND_EXPR, void_type_node,
3741                               build (BIT_AND_EXPR, integer_type_node,
3742                                      auto_delete, integer_one_node),
3743                               expr, void_zero_node);
3744               else
3745                 cond = expr;
3746             }
3747         }
3748       else if (base_binfo == NULL_TREE
3749                || (TREE_VIA_VIRTUAL (base_binfo) == 0
3750                    && ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo))))
3751         {
3752           tree virtual_size;
3753
3754           /* This is probably wrong. It should be the size of the virtual
3755              object being deleted.  */
3756           virtual_size = c_sizeof_nowarn (type);
3757
3758           cond = build (COND_EXPR, void_type_node,
3759                         build (BIT_AND_EXPR, integer_type_node, auto_delete, integer_one_node),
3760                         build_builtin_call (void_type_node, BID,
3761                                             build_tree_list (NULL_TREE, addr)),
3762                         void_zero_node);
3763         }
3764       else
3765         cond = NULL_TREE;
3766
3767       if (cond)
3768         exprstmt = build_tree_list (NULL_TREE, cond);
3769
3770       if (base_binfo
3771           && ! TREE_VIA_VIRTUAL (base_binfo)
3772           && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3773         {
3774           tree this_auto_delete;
3775
3776           if (BINFO_OFFSET_ZEROP (base_binfo))
3777             this_auto_delete = parent_auto_delete;
3778           else
3779             this_auto_delete = integer_zero_node;
3780
3781           expr = build_delete (TYPE_POINTER_TO (BINFO_TYPE (base_binfo)), addr,
3782                                this_auto_delete, flags, 0);
3783           exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
3784         }
3785
3786       /* Take care of the remaining baseclasses.  */
3787       for (i = 1; i < n_baseclasses; i++)
3788         {
3789           base_binfo = TREE_VEC_ELT (binfos, i);
3790           if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo))
3791               || TREE_VIA_VIRTUAL (base_binfo))
3792             continue;
3793
3794           /* May be zero offset if other baseclasses are virtual.  */
3795           expr = fold (build (PLUS_EXPR, TYPE_POINTER_TO (BINFO_TYPE (base_binfo)),
3796                               addr, BINFO_OFFSET (base_binfo)));
3797
3798           expr = build_delete (TYPE_POINTER_TO (BINFO_TYPE (base_binfo)), expr,
3799                                integer_zero_node,
3800                                flags, 0);
3801
3802           exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
3803         }
3804
3805       for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
3806         {
3807           if (TREE_CODE (member) != FIELD_DECL)
3808             continue;
3809           if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member)))
3810             {
3811               tree this_member = build_component_ref (ref, DECL_NAME (member), 0, 0);
3812               tree this_type = TREE_TYPE (member);
3813               expr = build_delete (this_type, this_member, integer_two_node, flags, 0);
3814               exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
3815             }
3816         }
3817
3818       if (exprstmt)
3819         return build_compound_expr (exprstmt);
3820       /* Virtual base classes make this function do nothing.  */
3821       return void_zero_node;
3822     }
3823 }
3824
3825 /* For type TYPE, delete the virtual baseclass objects of DECL.  */
3826
3827 tree
3828 build_vbase_delete (type, decl)
3829      tree type, decl;
3830 {
3831   tree vbases = CLASSTYPE_VBASECLASSES (type);
3832   tree result = NULL_TREE;
3833   tree addr = build_unary_op (ADDR_EXPR, decl, 0);
3834
3835   my_friendly_assert (addr != error_mark_node, 222);
3836
3837   while (vbases)
3838     {
3839       tree this_addr = convert_force (TYPE_POINTER_TO (BINFO_TYPE (vbases)),
3840                                       addr, 0);
3841       result = tree_cons (NULL_TREE,
3842                           build_delete (TREE_TYPE (this_addr), this_addr,
3843                                         integer_zero_node,
3844                                         LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0),
3845                           result);
3846       vbases = TREE_CHAIN (vbases);
3847     }
3848   return build_compound_expr (nreverse (result));
3849 }
3850
3851 /* Build a C++ vector delete expression.
3852    MAXINDEX is the number of elements to be deleted.
3853    ELT_SIZE is the nominal size of each element in the vector.
3854    BASE is the expression that should yield the store to be deleted.
3855    This function expands (or synthesizes) these calls itself.
3856    AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3857    AUTO_DELETE say whether each item in the container should be deallocated.
3858
3859    This also calls delete for virtual baseclasses of elements of the vector.
3860
3861    Update: MAXINDEX is no longer needed.  The size can be extracted from the
3862    start of the vector for pointers, and from the type for arrays.  We still
3863    use MAXINDEX for arrays because it happens to already have one of the
3864    values we'd have to extract.  (We could use MAXINDEX with pointers to
3865    confirm the size, and trap if the numbers differ; not clear that it'd
3866    be worth bothering.)  */
3867 tree
3868 build_vec_delete (base, maxindex, elt_size, auto_delete_vec, auto_delete,
3869                   use_global_delete)
3870      tree base, maxindex, elt_size;
3871      tree auto_delete_vec, auto_delete;
3872      int use_global_delete;
3873 {
3874   tree ptype = TREE_TYPE (base);
3875   tree type;
3876   tree virtual_size;
3877   /* Temporary variables used by the loop.  */
3878   tree tbase, size_exp, tbase_init;
3879
3880   /* This is the body of the loop that implements the deletion of a
3881      single element, and moves temp variables to next elements.  */
3882   tree body;
3883
3884   /* This is the LOOP_EXPR that governs the deletion of the elements.  */
3885   tree loop;
3886
3887   /* This is the thing that governs what to do after the loop has run.  */
3888   tree deallocate_expr = 0;
3889
3890   /* This is the BIND_EXPR which holds the outermost iterator of the
3891      loop.  It is convenient to set this variable up and test it before
3892      executing any other code in the loop.
3893      This is also the containing expression returned by this function.  */
3894   tree controller = NULL_TREE;
3895
3896   /* This is the BLOCK to record the symbol binding for debugging.  */
3897   tree block;
3898
3899   base = stabilize_reference (base);
3900
3901   /* Since we can use base many times, save_expr it. */
3902   if (TREE_SIDE_EFFECTS (base))
3903     base = save_expr (base);
3904
3905   if (TREE_CODE (ptype) == POINTER_TYPE)
3906     {
3907       /* Step back one from start of vector, and read dimension.  */
3908       tree cookie_addr = build (MINUS_EXPR, TYPE_POINTER_TO (BI_header_type),
3909                                 base, BI_header_size);
3910       tree cookie = build_indirect_ref (cookie_addr, NULL_PTR);
3911       maxindex = build_component_ref (cookie, nc_nelts_field_id, 0, 0);
3912       do
3913         ptype = TREE_TYPE (ptype);
3914       while (TREE_CODE (ptype) == ARRAY_TYPE);
3915     }
3916   else if (TREE_CODE (ptype) == ARRAY_TYPE)
3917     {
3918       /* get the total number of things in the array, maxindex is a bad name */
3919       maxindex = array_type_nelts_total (ptype);
3920       while (TREE_CODE (ptype) == ARRAY_TYPE)
3921         ptype = TREE_TYPE (ptype);
3922       base = build_unary_op (ADDR_EXPR, base, 1);
3923     }
3924   else
3925     {
3926       error ("type to vector delete is neither pointer or array type");
3927       return error_mark_node;
3928     }
3929   type = ptype;
3930   ptype = TYPE_POINTER_TO (type);
3931
3932   size_exp = size_in_bytes (type);
3933
3934   if (! IS_AGGR_TYPE (type) || ! TYPE_NEEDS_DESTRUCTOR (type))
3935     {
3936       loop = integer_zero_node;
3937       goto no_destructor;
3938     }
3939
3940   /* The below is short by BI_header_size */
3941   virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
3942
3943   tbase = build_decl (VAR_DECL, NULL_TREE, ptype);
3944   tbase_init = build_modify_expr (tbase, NOP_EXPR,
3945                                   fold (build (PLUS_EXPR, ptype,
3946                                                base,
3947                                                virtual_size)));
3948   DECL_REGISTER (tbase) = 1;
3949   controller = build (BIND_EXPR, void_type_node, tbase, 0, 0);
3950   TREE_SIDE_EFFECTS (controller) = 1;
3951   block = build_block (tbase, 0, 0, 0, 0);
3952   add_block_current_level (block);
3953
3954   if (auto_delete != integer_zero_node
3955       && auto_delete != integer_two_node)
3956     {
3957       tree base_tbd = convert (ptype,
3958                                build_binary_op (MINUS_EXPR,
3959                                                 convert (ptr_type_node, base),
3960                                                 BI_header_size,
3961                                                 1));
3962       /* This is the real size */
3963       virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
3964       body = build_tree_list (NULL_TREE,
3965                               build_x_delete (ptype, base_tbd,
3966                                               2 | use_global_delete,
3967                                               virtual_size));
3968       body = build (COND_EXPR, void_type_node,
3969                     build (BIT_AND_EXPR, integer_type_node,
3970                            auto_delete, integer_one_node),
3971                     body, integer_zero_node);
3972     }
3973   else
3974     body = NULL_TREE;
3975
3976   body = tree_cons (NULL_TREE,
3977                     build_delete (ptype, tbase, auto_delete,
3978                                   LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1),
3979                     body);
3980
3981   body = tree_cons (NULL_TREE,
3982                     build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)),
3983                     body);
3984
3985   body = tree_cons (NULL_TREE,
3986                     build (EXIT_EXPR, void_type_node,
3987                            build (EQ_EXPR, boolean_type_node, base, tbase)),
3988                     body);
3989
3990   loop = build (LOOP_EXPR, void_type_node, build_compound_expr (body));
3991
3992   loop = tree_cons (NULL_TREE, tbase_init,
3993                     tree_cons (NULL_TREE, loop, NULL_TREE));
3994   loop = build_compound_expr (loop);
3995
3996  no_destructor:
3997   /* If the delete flag is one, or anything else with the low bit set,
3998      delete the storage.  */
3999   if (auto_delete_vec == integer_zero_node
4000       || auto_delete_vec == integer_two_node)
4001     deallocate_expr = integer_zero_node;
4002   else
4003     {
4004       tree base_tbd;
4005
4006       /* The below is short by BI_header_size */
4007       virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
4008
4009       if (! TYPE_VEC_NEW_USES_COOKIE (type))
4010         /* no header */
4011         base_tbd = base;
4012       else
4013         {
4014           base_tbd = convert (ptype,
4015                               build_binary_op (MINUS_EXPR,
4016                                                convert (string_type_node, base),
4017                                                BI_header_size,
4018                                                1));
4019           /* True size with header. */
4020           virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
4021         }
4022       deallocate_expr = build_x_delete (ptype, base_tbd,
4023                                         2 | use_global_delete,
4024                                         virtual_size);
4025       if (auto_delete_vec != integer_one_node)
4026         deallocate_expr = build (COND_EXPR, void_type_node,
4027                                  build (BIT_AND_EXPR, integer_type_node,
4028                                         auto_delete_vec, integer_one_node),
4029                                  deallocate_expr, integer_zero_node);
4030     }
4031
4032   if (loop && deallocate_expr != integer_zero_node)
4033     {
4034       body = tree_cons (NULL_TREE, loop,
4035                         tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
4036       body = build_compound_expr (body);
4037     }
4038   else
4039     body = loop;
4040
4041   /* Outermost wrapper: If pointer is null, punt.  */
4042   body = build (COND_EXPR, void_type_node,
4043                 build (NE_EXPR, boolean_type_node, base, integer_zero_node),
4044                 body, integer_zero_node);
4045   body = build1 (NOP_EXPR, void_type_node, body);
4046
4047   if (controller)
4048     {
4049       TREE_OPERAND (controller, 1) = body;
4050       return controller;
4051     }
4052   else
4053     return convert (void_type_node, body);
4054 }