contrib/gcc-3.4/gcc/cp/class.c

   1 /* Functions related to building classes and their related objects.
   2    Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005
   4      Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  23
  24
  25 /* High-level class interface.  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "tm.h"
  31 #include "tree.h"
  32 #include "cp-tree.h"
  33 #include "flags.h"
  34 #include "rtl.h"
  35 #include "output.h"
  36 #include "toplev.h"
  37 #include "lex.h"
  38 #include "target.h"
  39 #include "convert.h"
  40
  41 /* The number of nested classes being processed.  If we are not in the
  42    scope of any class, this is zero.  */
  43
  44 int current_class_depth;
  45
  46 /* In order to deal with nested classes, we keep a stack of classes.
  47    The topmost entry is the innermost class, and is the entry at index
  48    CURRENT_CLASS_DEPTH  */
  49
  50 typedef struct class_stack_node {
  51   /* The name of the class.  */
  52   tree name;
  53
  54   /* The _TYPE node for the class.  */
  55   tree type;
  56
  57   /* The access specifier pending for new declarations in the scope of
  58      this class.  */
  59   tree access;
  60
  61   /* If were defining TYPE, the names used in this class.  */
  62   splay_tree names_used;
  63 }* class_stack_node_t;
  64
  65 typedef struct vtbl_init_data_s
  66 {
  67   /* The base for which we're building initializers.  */
  68   tree binfo;
  69   /* The type of the most-derived type.  */
  70   tree derived;
  71   /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
  72      unless ctor_vtbl_p is true.  */
  73   tree rtti_binfo;
  74   /* The negative-index vtable initializers built up so far.  These
  75      are in order from least negative index to most negative index.  */
  76   tree inits;
  77   /* The last (i.e., most negative) entry in INITS.  */
  78   tree* last_init;
  79   /* The binfo for the virtual base for which we're building
  80      vcall offset initializers.  */
  81   tree vbase;
  82   /* The functions in vbase for which we have already provided vcall
  83      offsets.  */
  84   varray_type fns;
  85   /* The vtable index of the next vcall or vbase offset.  */
  86   tree index;
  87   /* Nonzero if we are building the initializer for the primary
  88      vtable.  */
  89   int primary_vtbl_p;
  90   /* Nonzero if we are building the initializer for a construction
  91      vtable.  */
  92   int ctor_vtbl_p;
  93   /* True when adding vcall offset entries to the vtable.  False when
  94      merely computing the indices.  */
  95   bool generate_vcall_entries;
  96 } vtbl_init_data;
  97
  98 /* The type of a function passed to walk_subobject_offsets.  */
  99 typedef int (*subobject_offset_fn) (tree, tree, splay_tree);
 100
 101 /* The stack itself.  This is a dynamically resized array.  The
 102    number of elements allocated is CURRENT_CLASS_STACK_SIZE.  */
 103 static int current_class_stack_size;
 104 static class_stack_node_t current_class_stack;
 105
 106 /* An array of all local classes present in this translation unit, in
 107    declaration order.  */
 108 varray_type local_classes;
 109
 110 static tree get_vfield_name (tree);
 111 static void finish_struct_anon (tree);
 112 static tree get_vtable_name (tree);
 113 static tree get_basefndecls (tree, tree);
 114 static int build_primary_vtable (tree, tree);
 115 static int build_secondary_vtable (tree);
 116 static void finish_vtbls (tree);
 117 static void modify_vtable_entry (tree, tree, tree, tree, tree *);
 118 static void finish_struct_bits (tree);
 119 static int alter_access (tree, tree, tree);
 120 static void handle_using_decl (tree, tree);
 121 static void check_for_override (tree, tree);
 122 static tree dfs_modify_vtables (tree, void *);
 123 static tree modify_all_vtables (tree, tree);
 124 static void determine_primary_base (tree);
 125 static void finish_struct_methods (tree);
 126 static void maybe_warn_about_overly_private_class (tree);
 127 static int method_name_cmp (const void *, const void *);
 128 static int resort_method_name_cmp (const void *, const void *);
 129 static void add_implicitly_declared_members (tree, int, int, int);
 130 static tree fixed_type_or_null (tree, int *, int *);
 131 static tree resolve_address_of_overloaded_function (tree, tree, tsubst_flags_t,
 132                                                     bool, tree);
 133 static tree build_vtbl_ref_1 (tree, tree);
 134 static tree build_vtbl_initializer (tree, tree, tree, tree, int *);
 135 static int count_fields (tree);
 136 static int add_fields_to_record_type (tree, struct sorted_fields_type*, int);
 137 static void check_bitfield_decl (tree);
 138 static void check_field_decl (tree, tree, int *, int *, int *, int *);
 139 static void check_field_decls (tree, tree *, int *, int *, int *);
 140 static tree *build_base_field (record_layout_info, tree, splay_tree, tree *);
 141 static void build_base_fields (record_layout_info, splay_tree, tree *);
 142 static void check_methods (tree);
 143 static void remove_zero_width_bit_fields (tree);
 144 static void check_bases (tree, int *, int *, int *);
 145 static void check_bases_and_members (tree);
 146 static tree create_vtable_ptr (tree, tree *);
 147 static void include_empty_classes (record_layout_info);
 148 static void layout_class_type (tree, tree *);
 149 static void fixup_pending_inline (tree);
 150 static void fixup_inline_methods (tree);
 151 static void set_primary_base (tree, tree);
 152 static void propagate_binfo_offsets (tree, tree);
 153 static void layout_virtual_bases (record_layout_info, splay_tree);
 154 static void build_vbase_offset_vtbl_entries (tree, vtbl_init_data *);
 155 static void add_vcall_offset_vtbl_entries_r (tree, vtbl_init_data *);
 156 static void add_vcall_offset_vtbl_entries_1 (tree, vtbl_init_data *);
 157 static void build_vcall_offset_vtbl_entries (tree, vtbl_init_data *);
 158 static void add_vcall_offset (tree, tree, vtbl_init_data *);
 159 static void layout_vtable_decl (tree, int);
 160 static tree dfs_find_final_overrider (tree, void *);
 161 static tree dfs_find_final_overrider_post (tree, void *);
 162 static tree dfs_find_final_overrider_q (tree, int, void *);
 163 static tree find_final_overrider (tree, tree, tree);
 164 static int make_new_vtable (tree, tree);
 165 static int maybe_indent_hierarchy (FILE *, int, int);
 166 static tree dump_class_hierarchy_r (FILE *, int, tree, tree, int);
 167 static void dump_class_hierarchy (tree);
 168 static void dump_class_hierarchy_1 (FILE *, int, tree);
 169 static void dump_array (FILE *, tree);
 170 static void dump_vtable (tree, tree, tree);
 171 static void dump_vtt (tree, tree);
 172 static void dump_thunk (FILE *, int, tree);
 173 static tree build_vtable (tree, tree, tree);
 174 static void initialize_vtable (tree, tree);
 175 static void initialize_array (tree, tree);
 176 static void layout_nonempty_base_or_field (record_layout_info,
 177                                                    tree, tree, splay_tree);
 178 static tree end_of_class (tree, int);
 179 static bool layout_empty_base (tree, tree, splay_tree);
 180 static void accumulate_vtbl_inits (tree, tree, tree, tree, tree);
 181 static tree dfs_accumulate_vtbl_inits (tree, tree, tree, tree,
 182                                                tree);
 183 static void build_rtti_vtbl_entries (tree, vtbl_init_data *);
 184 static void build_vcall_and_vbase_vtbl_entries (tree,
 185                                                         vtbl_init_data *);
 186 static void mark_primary_bases (tree);
 187 static void clone_constructors_and_destructors (tree);
 188 static tree build_clone (tree, tree);
 189 static void update_vtable_entry_for_fn (tree, tree, tree, tree *, unsigned);
 190 static tree copy_virtuals (tree);
 191 static void build_ctor_vtbl_group (tree, tree);
 192 static void build_vtt (tree);
 193 static tree binfo_ctor_vtable (tree);
 194 static tree *build_vtt_inits (tree, tree, tree *, tree *);
 195 static tree dfs_build_secondary_vptr_vtt_inits (tree, void *);
 196 static tree dfs_ctor_vtable_bases_queue_p (tree, int, void *data);
 197 static tree dfs_fixup_binfo_vtbls (tree, void *);
 198 static int record_subobject_offset (tree, tree, splay_tree);
 199 static int check_subobject_offset (tree, tree, splay_tree);
 200 static int walk_subobject_offsets (tree, subobject_offset_fn,
 201                                            tree, splay_tree, tree, int);
 202 static void record_subobject_offsets (tree, tree, splay_tree, int);
 203 static int layout_conflict_p (tree, tree, splay_tree, int);
 204 static int splay_tree_compare_integer_csts (splay_tree_key k1,
 205                                                     splay_tree_key k2);
 206 static void warn_about_ambiguous_bases (tree);
 207 static bool type_requires_array_cookie (tree);
 208 static bool contains_empty_class_p (tree);
 209 static bool base_derived_from (tree, tree);
 210 static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree);
 211 static tree end_of_base (tree);
 212 static tree get_vcall_index (tree, tree);
 213
 214 /* Macros for dfs walking during vtt construction. See
 215    dfs_ctor_vtable_bases_queue_p, dfs_build_secondary_vptr_vtt_inits
 216    and dfs_fixup_binfo_vtbls.  */
 217 #define VTT_TOP_LEVEL_P(NODE) TREE_UNSIGNED (NODE)
 218 #define VTT_MARKED_BINFO_P(NODE) TREE_USED (NODE)
 219
 220 /* Variables shared between class.c and call.c.  */
 221
 222 #ifdef GATHER_STATISTICS
 223 int n_vtables = 0;
 224 int n_vtable_entries = 0;
 225 int n_vtable_searches = 0;
 226 int n_vtable_elems = 0;
 227 int n_convert_harshness = 0;
 228 int n_compute_conversion_costs = 0;
 229 int n_inner_fields_searched = 0;
 230 #endif
 231
 232 /* Convert to or from a base subobject.  EXPR is an expression of type
 233    `A' or `A*', an expression of type `B' or `B*' is returned.  To
 234    convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
 235    the B base instance within A.  To convert base A to derived B, CODE
 236    is MINUS_EXPR and BINFO is the binfo for the A instance within B.
 237    In this latter case, A must not be a morally virtual base of B.
 238    NONNULL is true if EXPR is known to be non-NULL (this is only
 239    needed when EXPR is of pointer type).  CV qualifiers are preserved
 240    from EXPR.  */
 241
 242 tree
 243 build_base_path (enum tree_code code,
 244                  tree expr,
 245                  tree binfo,
 246                  int nonnull)
 247 {
 248   tree v_binfo = NULL_TREE;
 249   tree d_binfo = NULL_TREE;
 250   tree probe;
 251   tree offset;
 252   tree target_type;
 253   tree null_test = NULL;
 254   tree ptr_target_type;
 255   int fixed_type_p;
 256   int want_pointer = TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE;
 257
 258   if (expr == error_mark_node || binfo == error_mark_node || !binfo)
 259     return error_mark_node;
 260
 261   for (probe = binfo; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
 262     {
 263       d_binfo = probe;
 264       if (!v_binfo && TREE_VIA_VIRTUAL (probe))
 265         v_binfo = probe;
 266     }
 267
 268   probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
 269   if (want_pointer)
 270     probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe));
 271
 272   my_friendly_assert (code == MINUS_EXPR
 273                       ? same_type_p (BINFO_TYPE (binfo), probe)
 274                       : code == PLUS_EXPR
 275                       ? same_type_p (BINFO_TYPE (d_binfo), probe)
 276                       : false, 20010723);
 277
 278   if (code == MINUS_EXPR && v_binfo)
 279     {
 280       error ("cannot convert from base `%T' to derived type `%T' via virtual base `%T'",
 281              BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo));
 282       return error_mark_node;
 283     }
 284
 285   if (!want_pointer)
 286     /* This must happen before the call to save_expr.  */
 287     expr = build_unary_op (ADDR_EXPR, expr, 0);
 288
 289   fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
 290   if (fixed_type_p <= 0 && TREE_SIDE_EFFECTS (expr))
 291     expr = save_expr (expr);
 292
 293   if (want_pointer && !nonnull)
 294     null_test = build (EQ_EXPR, boolean_type_node, expr, integer_zero_node);
 295
 296   offset = BINFO_OFFSET (binfo);
 297
 298   if (v_binfo && fixed_type_p <= 0)
 299     {
 300       /* Going via virtual base V_BINFO.  We need the static offset
 301          from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
 302          V_BINFO.  That offset is an entry in D_BINFO's vtable.  */
 303       tree v_offset;
 304
 305       if (fixed_type_p < 0 && in_base_initializer)
 306         {
 307           /* In a base member initializer, we cannot rely on
 308              the vtable being set up. We have to use the vtt_parm.  */
 309           tree derived = BINFO_INHERITANCE_CHAIN (v_binfo);
 310
 311           v_offset = build (PLUS_EXPR, TREE_TYPE (current_vtt_parm),
 312                             current_vtt_parm, BINFO_VPTR_INDEX (derived));
 313
 314           v_offset = build1 (INDIRECT_REF,
 315                              TREE_TYPE (TYPE_VFIELD (BINFO_TYPE (derived))),
 316                              v_offset);
 317
 318         }
 319       else
 320         v_offset = build_vfield_ref (build_indirect_ref (expr, NULL),
 321                                      TREE_TYPE (TREE_TYPE (expr)));
 322
 323       v_offset = build (PLUS_EXPR, TREE_TYPE (v_offset),
 324                         v_offset,  BINFO_VPTR_FIELD (v_binfo));
 325       v_offset = build1 (NOP_EXPR,
 326                          build_pointer_type (ptrdiff_type_node),
 327                          v_offset);
 328       v_offset = build_indirect_ref (v_offset, NULL);
 329
 330       offset = convert_to_integer (ptrdiff_type_node,
 331                                    size_diffop (offset,
 332                                                 BINFO_OFFSET (v_binfo)));
 333
 334       if (!integer_zerop (offset))
 335         v_offset = build (code, ptrdiff_type_node, v_offset, offset);
 336
 337       if (fixed_type_p < 0)
 338         /* Negative fixed_type_p means this is a constructor or destructor;
 339            virtual base layout is fixed in in-charge [cd]tors, but not in
 340            base [cd]tors.  */
 341         offset = build (COND_EXPR, ptrdiff_type_node,
 342                         build (EQ_EXPR, boolean_type_node,
 343                                current_in_charge_parm, integer_zero_node),
 344                         v_offset,
 345                         BINFO_OFFSET (binfo));
 346       else
 347         offset = v_offset;
 348     }
 349
 350   target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo);
 351
 352   target_type = cp_build_qualified_type
 353     (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr))));
 354   ptr_target_type = build_pointer_type (target_type);
 355   if (want_pointer)
 356     target_type = ptr_target_type;
 357
 358   expr = build1 (NOP_EXPR, ptr_target_type, expr);
 359
 360   if (!integer_zerop (offset))
 361     expr = build (code, ptr_target_type, expr, offset);
 362   else
 363     null_test = NULL;
 364
 365   if (!want_pointer)
 366     expr = build_indirect_ref (expr, NULL);
 367
 368   if (null_test)
 369     expr = build (COND_EXPR, target_type, null_test,
 370                   build1 (NOP_EXPR, target_type, integer_zero_node),
 371                   expr);
 372
 373   return expr;
 374 }
 375
 376 /* Convert OBJECT to the base TYPE.  If CHECK_ACCESS is true, an error
 377    message is emitted if TYPE is inaccessible.  OBJECT is assumed to
 378    be non-NULL.  */
 379
 380 tree
 381 convert_to_base (tree object, tree type, bool check_access)
 382 {
 383   tree binfo;
 384
 385   binfo = lookup_base (TREE_TYPE (object), type,
 386                        check_access ? ba_check : ba_ignore,
 387                        NULL);
 388   if (!binfo || binfo == error_mark_node)
 389     return error_mark_node;
 390
 391   return build_base_path (PLUS_EXPR, object, binfo, /*nonnull=*/1);
 392 }
 393
 394 /* EXPR is an expression with class type.  BASE is a base class (a
 395    BINFO) of that class type.  Returns EXPR, converted to the BASE
 396    type.  This function assumes that EXPR is the most derived class;
 397    therefore virtual bases can be found at their static offsets.  */
 398
 399 tree
 400 convert_to_base_statically (tree expr, tree base)
 401 {
 402   tree expr_type;
 403
 404   expr_type = TREE_TYPE (expr);
 405   if (!same_type_p (expr_type, BINFO_TYPE (base)))
 406     {
 407       tree pointer_type;
 408
 409       pointer_type = build_pointer_type (expr_type);
 410       expr = build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1);
 411       if (!integer_zerop (BINFO_OFFSET (base)))
 412           expr = build (PLUS_EXPR, pointer_type, expr,
 413                         build_nop (pointer_type, BINFO_OFFSET (base)));
 414       expr = build_nop (build_pointer_type (BINFO_TYPE (base)), expr);
 415       expr = build1 (INDIRECT_REF, BINFO_TYPE (base), expr);
 416     }
 417
 418   return expr;
 419 }
 420
 421 \f
 422 /* Given an object INSTANCE, return an expression which yields the
 423    vtable element corresponding to INDEX.  There are many special
 424    cases for INSTANCE which we take care of here, mainly to avoid
 425    creating extra tree nodes when we don't have to.  */
 426
 427 static tree
 428 build_vtbl_ref_1 (tree instance, tree idx)
 429 {
 430   tree aref;
 431   tree vtbl = NULL_TREE;
 432
 433   /* Try to figure out what a reference refers to, and
 434      access its virtual function table directly.  */
 435
 436   int cdtorp = 0;
 437   tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp);
 438
 439   tree basetype = non_reference (TREE_TYPE (instance));
 440
 441   if (fixed_type && !cdtorp)
 442     {
 443       tree binfo = lookup_base (fixed_type, basetype,
 444                                 ba_ignore|ba_quiet, NULL);
 445       if (binfo)
 446         vtbl = BINFO_VTABLE (binfo);
 447     }
 448
 449   if (!vtbl)
 450     vtbl = build_vfield_ref (instance, basetype);
 451
 452   assemble_external (vtbl);
 453
 454   aref = build_array_ref (vtbl, idx);
 455
 456   return aref;
 457 }
 458
 459 tree
 460 build_vtbl_ref (tree instance, tree idx)
 461 {
 462   tree aref = build_vtbl_ref_1 (instance, idx);
 463
 464   return aref;
 465 }
 466
 467 /* Given an object INSTANCE, return an expression which yields a
 468    function pointer corresponding to vtable element INDEX.  */
 469
 470 tree
 471 build_vfn_ref (tree instance, tree idx)
 472 {
 473   tree aref = build_vtbl_ref_1 (instance, idx);
 474
 475   /* When using function descriptors, the address of the
 476      vtable entry is treated as a function pointer.  */
 477   if (TARGET_VTABLE_USES_DESCRIPTORS)
 478     aref = build1 (NOP_EXPR, TREE_TYPE (aref),
 479                    build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1));
 480
 481   return aref;
 482 }
 483
 484 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
 485    for the given TYPE.  */
 486
 487 static tree
 488 get_vtable_name (tree type)
 489 {
 490   return mangle_vtbl_for_type (type);
 491 }
 492
 493 /* Return an IDENTIFIER_NODE for the name of the virtual table table
 494    for TYPE.  */
 495
 496 tree
 497 get_vtt_name (tree type)
 498 {
 499   return mangle_vtt_for_type (type);
 500 }
 501
 502 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
 503    (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
 504    Use NAME for the name of the vtable, and VTABLE_TYPE for its type.  */
 505
 506 static tree
 507 build_vtable (tree class_type, tree name, tree vtable_type)
 508 {
 509   tree decl;
 510
 511   decl = build_lang_decl (VAR_DECL, name, vtable_type);
 512   /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
 513      now to avoid confusion in mangle_decl.  */
 514   SET_DECL_ASSEMBLER_NAME (decl, name);
 515   DECL_CONTEXT (decl) = class_type;
 516   DECL_ARTIFICIAL (decl) = 1;
 517   TREE_STATIC (decl) = 1;
 518   TREE_READONLY (decl) = 1;
 519   DECL_VIRTUAL_P (decl) = 1;
 520   DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN;
 521   DECL_VTABLE_OR_VTT_P (decl) = 1;
 522
 523   /* At one time the vtable info was grabbed 2 words at a time.  This
 524      fails on sparc unless you have 8-byte alignment.  (tiemann) */
 525   DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
 526                            DECL_ALIGN (decl));
 527
 528   import_export_vtable (decl, class_type, 0);
 529
 530   return decl;
 531 }
 532
 533 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
 534    or even complete.  If this does not exist, create it.  If COMPLETE is
 535    nonzero, then complete the definition of it -- that will render it
 536    impossible to actually build the vtable, but is useful to get at those
 537    which are known to exist in the runtime.  */
 538
 539 tree
 540 get_vtable_decl (tree type, int complete)
 541 {
 542   tree decl;
 543
 544   if (CLASSTYPE_VTABLES (type))
 545     return CLASSTYPE_VTABLES (type);
 546
 547   decl = build_vtable (type, get_vtable_name (type), vtbl_type_node);
 548   CLASSTYPE_VTABLES (type) = decl;
 549
 550   if (complete)
 551     {
 552       DECL_EXTERNAL (decl) = 1;
 553       cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
 554     }
 555
 556   return decl;
 557 }
 558
 559 /* Returns a copy of the BINFO_VIRTUALS list in BINFO.  The
 560    BV_VCALL_INDEX for each entry is cleared.  */
 561
 562 static tree
 563 copy_virtuals (tree binfo)
 564 {
 565   tree copies;
 566   tree t;
 567
 568   copies = copy_list (BINFO_VIRTUALS (binfo));
 569   for (t = copies; t; t = TREE_CHAIN (t))
 570     BV_VCALL_INDEX (t) = NULL_TREE;
 571
 572   return copies;
 573 }
 574
 575 /* Build the primary virtual function table for TYPE.  If BINFO is
 576    non-NULL, build the vtable starting with the initial approximation
 577    that it is the same as the one which is the head of the association
 578    list.  Returns a nonzero value if a new vtable is actually
 579    created.  */
 580
 581 static int
 582 build_primary_vtable (tree binfo, tree type)
 583 {
 584   tree decl;
 585   tree virtuals;
 586
 587   decl = get_vtable_decl (type, /*complete=*/0);
 588
 589   if (binfo)
 590     {
 591       if (BINFO_NEW_VTABLE_MARKED (binfo))
 592         /* We have already created a vtable for this base, so there's
 593            no need to do it again.  */
 594         return 0;
 595
 596       virtuals = copy_virtuals (binfo);
 597       TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo));
 598       DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl));
 599       DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
 600     }
 601   else
 602     {
 603       my_friendly_assert (TREE_TYPE (decl) == vtbl_type_node, 20000118);
 604       virtuals = NULL_TREE;
 605     }
 606
 607 #ifdef GATHER_STATISTICS
 608   n_vtables += 1;
 609   n_vtable_elems += list_length (virtuals);
 610 #endif
 611
 612   /* Initialize the association list for this type, based
 613      on our first approximation.  */
 614   TYPE_BINFO_VTABLE (type) = decl;
 615   TYPE_BINFO_VIRTUALS (type) = virtuals;
 616   SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type));
 617   return 1;
 618 }
 619
 620 /* Give BINFO a new virtual function table which is initialized
 621    with a skeleton-copy of its original initialization.  The only
 622    entry that changes is the `delta' entry, so we can really
 623    share a lot of structure.
 624
 625    FOR_TYPE is the most derived type which caused this table to
 626    be needed.
 627
 628    Returns nonzero if we haven't met BINFO before.
 629
 630    The order in which vtables are built (by calling this function) for
 631    an object must remain the same, otherwise a binary incompatibility
 632    can result.  */
 633
 634 static int
 635 build_secondary_vtable (tree binfo)
 636 {
 637   if (BINFO_NEW_VTABLE_MARKED (binfo))
 638     /* We already created a vtable for this base.  There's no need to
 639        do it again.  */
 640     return 0;
 641
 642   /* Remember that we've created a vtable for this BINFO, so that we
 643      don't try to do so again.  */
 644   SET_BINFO_NEW_VTABLE_MARKED (binfo);
 645
 646   /* Make fresh virtual list, so we can smash it later.  */
 647   BINFO_VIRTUALS (binfo) = copy_virtuals (binfo);
 648
 649   /* Secondary vtables are laid out as part of the same structure as
 650      the primary vtable.  */
 651   BINFO_VTABLE (binfo) = NULL_TREE;
 652   return 1;
 653 }
 654
 655 /* Create a new vtable for BINFO which is the hierarchy dominated by
 656    T. Return nonzero if we actually created a new vtable.  */
 657
 658 static int
 659 make_new_vtable (tree t, tree binfo)
 660 {
 661   if (binfo == TYPE_BINFO (t))
 662     /* In this case, it is *type*'s vtable we are modifying.  We start
 663        with the approximation that its vtable is that of the
 664        immediate base class.  */
 665     /* ??? This actually passes TYPE_BINFO (t), not the primary base binfo,
 666        since we've updated DECL_CONTEXT (TYPE_VFIELD (t)) by now.  */
 667     return build_primary_vtable (TYPE_BINFO (DECL_CONTEXT (TYPE_VFIELD (t))),
 668                                  t);
 669   else
 670     /* This is our very own copy of `basetype' to play with.  Later,
 671        we will fill in all the virtual functions that override the
 672        virtual functions in these base classes which are not defined
 673        by the current type.  */
 674     return build_secondary_vtable (binfo);
 675 }
 676
 677 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
 678    (which is in the hierarchy dominated by T) list FNDECL as its
 679    BV_FN.  DELTA is the required constant adjustment from the `this'
 680    pointer where the vtable entry appears to the `this' required when
 681    the function is actually called.  */
 682
 683 static void
 684 modify_vtable_entry (tree t,
 685                      tree binfo,
 686                      tree fndecl,
 687                      tree delta,
 688                      tree *virtuals)
 689 {
 690   tree v;
 691
 692   v = *virtuals;
 693
 694   if (fndecl != BV_FN (v)
 695       || !tree_int_cst_equal (delta, BV_DELTA (v)))
 696     {
 697       /* We need a new vtable for BINFO.  */
 698       if (make_new_vtable (t, binfo))
 699         {
 700           /* If we really did make a new vtable, we also made a copy
 701              of the BINFO_VIRTUALS list.  Now, we have to find the
 702              corresponding entry in that list.  */
 703           *virtuals = BINFO_VIRTUALS (binfo);
 704           while (BV_FN (*virtuals) != BV_FN (v))
 705             *virtuals = TREE_CHAIN (*virtuals);
 706           v = *virtuals;
 707         }
 708
 709       BV_DELTA (v) = delta;
 710       BV_VCALL_INDEX (v) = NULL_TREE;
 711       BV_FN (v) = fndecl;
 712     }
 713 }
 714
 715 \f
 716 /* Add method METHOD to class TYPE.  If ERROR_P is true, we are adding
 717    the method after the class has already been defined because a
 718    declaration for it was seen.  (Even though that is erroneous, we
 719    add the method for improved error recovery.)  */
 720
 721 void
 722 add_method (tree type, tree method, int error_p)
 723 {
 724   int using;
 725   int len;
 726   int slot;
 727   tree method_vec;
 728   int template_conv_p;
 729
 730   if (method == error_mark_node)
 731     return;
 732
 733   using = (DECL_CONTEXT (method) != type);
 734   template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL
 735                      && DECL_TEMPLATE_CONV_FN_P (method));
 736
 737   if (!CLASSTYPE_METHOD_VEC (type))
 738     /* Make a new method vector.  We start with 8 entries.  We must
 739        allocate at least two (for constructors and destructors), and
 740        we're going to end up with an assignment operator at some point
 741        as well.
 742
 743        We could use a TREE_LIST for now, and convert it to a TREE_VEC
 744        in finish_struct, but we would probably waste more memory
 745        making the links in the list than we would by over-allocating
 746        the size of the vector here.  Furthermore, we would complicate
 747        all the code that expects this to be a vector.  */
 748     CLASSTYPE_METHOD_VEC (type) = make_tree_vec (8);
 749
 750   method_vec = CLASSTYPE_METHOD_VEC (type);
 751   len = TREE_VEC_LENGTH (method_vec);
 752
 753   /* Constructors and destructors go in special slots.  */
 754   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method))
 755     slot = CLASSTYPE_CONSTRUCTOR_SLOT;
 756   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
 757     {
 758       slot = CLASSTYPE_DESTRUCTOR_SLOT;
 759       TYPE_HAS_DESTRUCTOR (type) = 1;
 760
 761       if (TYPE_FOR_JAVA (type))
 762         error (DECL_ARTIFICIAL (method)
 763                ? "Java class '%T' cannot have an implicit non-trivial destructor"
 764                : "Java class '%T' cannot have a destructor",
 765                DECL_CONTEXT (method));
 766     }
 767   else
 768     {
 769       int have_template_convs_p = 0;
 770
 771       /* See if we already have an entry with this name.  */
 772       for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; slot < len; ++slot)
 773         {
 774           tree m = TREE_VEC_ELT (method_vec, slot);
 775
 776           if (!m)
 777             break;
 778           m = OVL_CURRENT (m);
 779
 780           if (template_conv_p)
 781             {
 782               have_template_convs_p = (TREE_CODE (m) == TEMPLATE_DECL
 783                                        && DECL_TEMPLATE_CONV_FN_P (m));
 784
 785               /* If we need to move things up, see if there's
 786                  space.  */
 787               if (!have_template_convs_p)
 788                 {
 789                   slot = len - 1;
 790                   if (TREE_VEC_ELT (method_vec, slot))
 791                     slot++;
 792                 }
 793               break;
 794             }
 795           if (DECL_NAME (m) == DECL_NAME (method))
 796             break;
 797         }
 798
 799       if (slot == len)
 800         {
 801           /* We need a bigger method vector.  */
 802           int new_len;
 803           tree new_vec;
 804
 805           /* In the non-error case, we are processing a class
 806              definition.  Double the size of the vector to give room
 807              for new methods.  */
 808           if (!error_p)
 809             new_len = 2 * len;
 810           /* In the error case, the vector is already complete.  We
 811              don't expect many errors, and the rest of the front-end
 812              will get confused if there are empty slots in the vector.  */
 813           else
 814             new_len = len + 1;
 815
 816           new_vec = make_tree_vec (new_len);
 817           memcpy (&TREE_VEC_ELT (new_vec, 0), &TREE_VEC_ELT (method_vec, 0),
 818                   len * sizeof (tree));
 819           len = new_len;
 820           method_vec = CLASSTYPE_METHOD_VEC (type) = new_vec;
 821         }
 822
 823       if (DECL_CONV_FN_P (method) && !TREE_VEC_ELT (method_vec, slot))
 824         {
 825           /* Type conversion operators have to come before ordinary
 826              methods; add_conversions depends on this to speed up
 827              looking for conversion operators.  So, if necessary, we
 828              slide some of the vector elements up.  In theory, this
 829              makes this algorithm O(N^2) but we don't expect many
 830              conversion operators.  */
 831           if (template_conv_p)
 832             slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
 833           else
 834             for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; slot < len; ++slot)
 835               {
 836                 tree fn = TREE_VEC_ELT (method_vec, slot);
 837
 838                 if (!fn)
 839                   /* There are no more entries in the vector, so we
 840                      can insert the new conversion operator here.  */
 841                   break;
 842
 843                 if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
 844                   /* We can insert the new function right at the
 845                      SLOTth position.  */
 846                   break;
 847               }
 848
 849           if (template_conv_p && have_template_convs_p)
 850             /*OK*/;
 851           else if (!TREE_VEC_ELT (method_vec, slot))
 852             /* There is nothing in the Ith slot, so we can avoid
 853                moving anything.  */
 854                 ;
 855           else
 856             {
 857               /* We know the last slot in the vector is empty
 858                  because we know that at this point there's room
 859                  for a new function.  */
 860               memmove (&TREE_VEC_ELT (method_vec, slot + 1),
 861                        &TREE_VEC_ELT (method_vec, slot),
 862                        (len - slot - 1) * sizeof (tree));
 863               TREE_VEC_ELT (method_vec, slot) = NULL_TREE;
 864             }
 865         }
 866     }
 867
 868   if (processing_template_decl)
 869     /* TYPE is a template class.  Don't issue any errors now; wait
 870        until instantiation time to complain.  */
 871     ;
 872   else
 873     {
 874       tree fns;
 875
 876       /* Check to see if we've already got this method.  */
 877       for (fns = TREE_VEC_ELT (method_vec, slot);
 878            fns;
 879            fns = OVL_NEXT (fns))
 880         {
 881           tree fn = OVL_CURRENT (fns);
 882           tree parms1;
 883           tree parms2;
 884           bool same = 1;
 885
 886           if (TREE_CODE (fn) != TREE_CODE (method))
 887             continue;
 888
 889           /* [over.load] Member function declarations with the
 890              same name and the same parameter types cannot be
 891              overloaded if any of them is a static member
 892              function declaration.
 893
 894              [namespace.udecl] When a using-declaration brings names
 895              from a base class into a derived class scope, member
 896              functions in the derived class override and/or hide member
 897              functions with the same name and parameter types in a base
 898              class (rather than conflicting).  */
 899           parms1 = TYPE_ARG_TYPES (TREE_TYPE (fn));
 900           parms2 = TYPE_ARG_TYPES (TREE_TYPE (method));
 901
 902           /* Compare the quals on the 'this' parm.  Don't compare
 903              the whole types, as used functions are treated as
 904              coming from the using class in overload resolution.  */
 905           if (! DECL_STATIC_FUNCTION_P (fn)
 906               && ! DECL_STATIC_FUNCTION_P (method)
 907               && (TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms1)))
 908                   != TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms2)))))
 909             same = 0;
 910
 911           /* For templates, the template parms must be identical.  */
 912           if (TREE_CODE (fn) == TEMPLATE_DECL
 913               && !comp_template_parms (DECL_TEMPLATE_PARMS (fn),
 914                                        DECL_TEMPLATE_PARMS (method)))
 915             same = 0;
 916
 917           if (! DECL_STATIC_FUNCTION_P (fn))
 918             parms1 = TREE_CHAIN (parms1);
 919           if (! DECL_STATIC_FUNCTION_P (method))
 920             parms2 = TREE_CHAIN (parms2);
 921
 922           if (same && compparms (parms1, parms2)
 923               && (!DECL_CONV_FN_P (fn)
 924                   || same_type_p (TREE_TYPE (TREE_TYPE (fn)),
 925                                   TREE_TYPE (TREE_TYPE (method)))))
 926             {
 927               if (using && DECL_CONTEXT (fn) == type)
 928                 /* Defer to the local function.  */
 929                 return;
 930               else
 931                 {
 932                   cp_error_at ("`%#D' and `%#D' cannot be overloaded",
 933                                method, fn);
 934
 935                   /* We don't call duplicate_decls here to merge
 936                      the declarations because that will confuse
 937                      things if the methods have inline
 938                      definitions.  In particular, we will crash
 939                      while processing the definitions.  */
 940                   return;
 941                 }
 942             }
 943         }
 944     }
 945
 946   /* Actually insert the new method.  */
 947   TREE_VEC_ELT (method_vec, slot)
 948     = build_overload (method, TREE_VEC_ELT (method_vec, slot));
 949
 950   /* Add the new binding.  */
 951   if (!DECL_CONSTRUCTOR_P (method)
 952       && !DECL_DESTRUCTOR_P (method))
 953     push_class_level_binding (DECL_NAME (method),
 954                               TREE_VEC_ELT (method_vec, slot));
 955 }
 956
 957 /* Subroutines of finish_struct.  */
 958
 959 /* Change the access of FDECL to ACCESS in T.  Return 1 if change was
 960    legit, otherwise return 0.  */
 961
 962 static int
 963 alter_access (tree t, tree fdecl, tree access)
 964 {
 965   tree elem;
 966
 967   if (!DECL_LANG_SPECIFIC (fdecl))
 968     retrofit_lang_decl (fdecl);
 969
 970   my_friendly_assert (!DECL_DISCRIMINATOR_P (fdecl), 20030624);
 971
 972   elem = purpose_member (t, DECL_ACCESS (fdecl));
 973   if (elem)
 974     {
 975       if (TREE_VALUE (elem) != access)
 976         {
 977           if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
 978             cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl));
 979           else
 980             error ("conflicting access specifications for field `%s', ignored",
 981                    IDENTIFIER_POINTER (DECL_NAME (fdecl)));
 982         }
 983       else
 984         {
 985           /* They're changing the access to the same thing they changed
 986              it to before.  That's OK.  */
 987           ;
 988         }
 989     }
 990   else
 991     {
 992       perform_or_defer_access_check (TYPE_BINFO (t), fdecl);
 993       DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
 994       return 1;
 995     }
 996   return 0;
 997 }
 998
 999 /* Process the USING_DECL, which is a member of T.  */
1000
1001 static void
1002 handle_using_decl (tree using_decl, tree t)
1003 {
1004   tree ctype = DECL_INITIAL (using_decl);
1005   tree name = DECL_NAME (using_decl);
1006   tree access
1007     = TREE_PRIVATE (using_decl) ? access_private_node
1008     : TREE_PROTECTED (using_decl) ? access_protected_node
1009     : access_public_node;
1010   tree fdecl, binfo;
1011   tree flist = NULL_TREE;
1012   tree old_value;
1013
1014   if (ctype == error_mark_node)
1015     return;
1016
1017   binfo = lookup_base (t, ctype, ba_any, NULL);
1018   if (! binfo)
1019     {
1020       location_t saved_loc = input_location;
1021
1022       input_location = DECL_SOURCE_LOCATION (using_decl);
1023       error_not_base_type (ctype, t);
1024       input_location = saved_loc;
1025       return;
1026     }
1027
1028   if (constructor_name_p (name, ctype))
1029     {
1030       cp_error_at ("`%D' names constructor", using_decl);
1031       return;
1032     }
1033   if (constructor_name_p (name, t))
1034     {
1035       cp_error_at ("`%D' invalid in `%T'", using_decl, t);
1036       return;
1037     }
1038
1039   fdecl = lookup_member (binfo, name, 0, false);
1040
1041   if (!fdecl)
1042     {
1043       cp_error_at ("no members matching `%D' in `%#T'", using_decl, ctype);
1044       return;
1045     }
1046
1047   if (BASELINK_P (fdecl))
1048     /* Ignore base type this came from.  */
1049     fdecl = BASELINK_FUNCTIONS (fdecl);
1050
1051   old_value = IDENTIFIER_CLASS_VALUE (name);
1052   if (old_value)
1053     {
1054       if (is_overloaded_fn (old_value))
1055         old_value = OVL_CURRENT (old_value);
1056
1057       if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t)
1058         /* OK */;
1059       else
1060         old_value = NULL_TREE;
1061     }
1062
1063   if (is_overloaded_fn (fdecl))
1064     flist = fdecl;
1065
1066   if (! old_value)
1067     ;
1068   else if (is_overloaded_fn (old_value))
1069     {
1070       if (flist)
1071         /* It's OK to use functions from a base when there are functions with
1072            the same name already present in the current class.  */;
1073       else
1074         {
1075           cp_error_at ("`%D' invalid in `%#T'", using_decl, t);
1076           cp_error_at ("  because of local method `%#D' with same name",
1077                        OVL_CURRENT (old_value));
1078           return;
1079         }
1080     }
1081   else if (!DECL_ARTIFICIAL (old_value))
1082     {
1083       cp_error_at ("`%D' invalid in `%#T'", using_decl, t);
1084       cp_error_at ("  because of local member `%#D' with same name", old_value);
1085       return;
1086     }
1087
1088   /* Make type T see field decl FDECL with access ACCESS.  */
1089   if (flist)
1090     for (; flist; flist = OVL_NEXT (flist))
1091       {
1092         add_method (t, OVL_CURRENT (flist), /*error_p=*/0);
1093         alter_access (t, OVL_CURRENT (flist), access);
1094       }
1095   else
1096     alter_access (t, fdecl, access);
1097 }
1098 \f
1099 /* Run through the base clases of T, updating
1100    CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1101    NO_CONST_ASN_REF_P.  Also set flag bits in T based on properties of
1102    the bases.  */
1103
1104 static void
1105 check_bases (tree t,
1106              int* cant_have_default_ctor_p,
1107              int* cant_have_const_ctor_p,
1108              int* no_const_asn_ref_p)
1109 {
1110   int n_baseclasses;
1111   int i;
1112   int seen_non_virtual_nearly_empty_base_p;
1113   tree binfos;
1114
1115   binfos = TYPE_BINFO_BASETYPES (t);
1116   n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1117   seen_non_virtual_nearly_empty_base_p = 0;
1118
1119   /* An aggregate cannot have baseclasses.  */
1120   CLASSTYPE_NON_AGGREGATE (t) |= (n_baseclasses != 0);
1121
1122   for (i = 0; i < n_baseclasses; ++i)
1123     {
1124       tree base_binfo;
1125       tree basetype;
1126
1127       /* Figure out what base we're looking at.  */
1128       base_binfo = TREE_VEC_ELT (binfos, i);
1129       basetype = TREE_TYPE (base_binfo);
1130
1131       /* If the type of basetype is incomplete, then we already
1132          complained about that fact (and we should have fixed it up as
1133          well).  */
1134       if (!COMPLETE_TYPE_P (basetype))
1135         {
1136           int j;
1137           /* The base type is of incomplete type.  It is
1138              probably best to pretend that it does not
1139              exist.  */
1140           if (i == n_baseclasses-1)
1141             TREE_VEC_ELT (binfos, i) = NULL_TREE;
1142           TREE_VEC_LENGTH (binfos) -= 1;
1143           n_baseclasses -= 1;
1144           for (j = i; j+1 < n_baseclasses; j++)
1145             TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1);
1146           continue;
1147         }
1148
1149       /* Effective C++ rule 14.  We only need to check TYPE_POLYMORPHIC_P
1150          here because the case of virtual functions but non-virtual
1151          dtor is handled in finish_struct_1.  */
1152       if (warn_ecpp && ! TYPE_POLYMORPHIC_P (basetype)
1153           && TYPE_HAS_DESTRUCTOR (basetype))
1154         warning ("base class `%#T' has a non-virtual destructor",
1155                     basetype);
1156
1157       /* If the base class doesn't have copy constructors or
1158          assignment operators that take const references, then the
1159          derived class cannot have such a member automatically
1160          generated.  */
1161       if (! TYPE_HAS_CONST_INIT_REF (basetype))
1162         *cant_have_const_ctor_p = 1;
1163       if (TYPE_HAS_ASSIGN_REF (basetype)
1164           && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1165         *no_const_asn_ref_p = 1;
1166       /* Similarly, if the base class doesn't have a default
1167          constructor, then the derived class won't have an
1168          automatically generated default constructor.  */
1169       if (TYPE_HAS_CONSTRUCTOR (basetype)
1170           && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
1171         {
1172           *cant_have_default_ctor_p = 1;
1173           if (! TYPE_HAS_CONSTRUCTOR (t))
1174             pedwarn ("base `%T' with only non-default constructor in class without a constructor",
1175                         basetype);
1176         }
1177
1178       if (TREE_VIA_VIRTUAL (base_binfo))
1179         /* A virtual base does not effect nearly emptiness.  */
1180         ;
1181       else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
1182         {
1183           if (seen_non_virtual_nearly_empty_base_p)
1184             /* And if there is more than one nearly empty base, then the
1185                derived class is not nearly empty either.  */
1186             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1187           else
1188             /* Remember we've seen one.  */
1189             seen_non_virtual_nearly_empty_base_p = 1;
1190         }
1191       else if (!is_empty_class (basetype))
1192         /* If the base class is not empty or nearly empty, then this
1193            class cannot be nearly empty.  */
1194         CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1195
1196       /* A lot of properties from the bases also apply to the derived
1197          class.  */
1198       TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1199       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1200         |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype);
1201       TYPE_HAS_COMPLEX_ASSIGN_REF (t)
1202         |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1203       TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1204       TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype);
1205       CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t)
1206         |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype);
1207     }
1208 }
1209
1210 /* Set BINFO_PRIMARY_BASE_OF for all binfos in the hierarchy
1211    dominated by TYPE that are primary bases.  */
1212
1213 static void
1214 mark_primary_bases (tree type)
1215 {
1216   tree binfo;
1217
1218   /* Walk the bases in inheritance graph order.  */
1219   for (binfo = TYPE_BINFO (type); binfo; binfo = TREE_CHAIN (binfo))
1220     {
1221       tree base_binfo = get_primary_binfo (binfo);
1222
1223       if (!base_binfo)
1224         /* Not a dynamic base.  */;
1225       else if (BINFO_PRIMARY_P (base_binfo))
1226         BINFO_LOST_PRIMARY_P (binfo) = 1;
1227       else
1228         {
1229           BINFO_PRIMARY_BASE_OF (base_binfo) = binfo;
1230           /* A virtual binfo might have been copied from within
1231              another hierarchy. As we're about to use it as a primary
1232              base, make sure the offsets match.  */
1233           if (TREE_VIA_VIRTUAL (base_binfo))
1234             {
1235               tree delta = size_diffop (convert (ssizetype,
1236                                                  BINFO_OFFSET (binfo)),
1237                                         convert (ssizetype,
1238                                                  BINFO_OFFSET (base_binfo)));
1239
1240               propagate_binfo_offsets (base_binfo, delta);
1241             }
1242         }
1243     }
1244 }
1245
1246 /* Make the BINFO the primary base of T.  */
1247
1248 static void
1249 set_primary_base (tree t, tree binfo)
1250 {
1251   tree basetype;
1252
1253   CLASSTYPE_PRIMARY_BINFO (t) = binfo;
1254   basetype = BINFO_TYPE (binfo);
1255   TYPE_BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (basetype);
1256   TYPE_BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (basetype);
1257   TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1258 }
1259
1260 /* Determine the primary class for T.  */
1261
1262 static void
1263 determine_primary_base (tree t)
1264 {
1265   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1266   tree vbases;
1267   tree type_binfo;
1268
1269   /* If there are no baseclasses, there is certainly no primary base.  */
1270   if (n_baseclasses == 0)
1271     return;
1272
1273   type_binfo = TYPE_BINFO (t);
1274
1275   for (i = 0; i < n_baseclasses; i++)
1276     {
1277       tree base_binfo = BINFO_BASETYPE (type_binfo, i);
1278       tree basetype = BINFO_TYPE (base_binfo);
1279
1280       if (TYPE_CONTAINS_VPTR_P (basetype))
1281         {
1282           /* We prefer a non-virtual base, although a virtual one will
1283              do.  */
1284           if (TREE_VIA_VIRTUAL (base_binfo))
1285             continue;
1286
1287           if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
1288             {
1289               set_primary_base (t, base_binfo);
1290               CLASSTYPE_VFIELDS (t) = copy_list (CLASSTYPE_VFIELDS (basetype));
1291             }
1292           else
1293             {
1294               tree vfields;
1295
1296               /* Only add unique vfields, and flatten them out as we go.  */
1297               for (vfields = CLASSTYPE_VFIELDS (basetype);
1298                    vfields;
1299                    vfields = TREE_CHAIN (vfields))
1300                 if (VF_BINFO_VALUE (vfields) == NULL_TREE
1301                     || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1302                   CLASSTYPE_VFIELDS (t)
1303                     = tree_cons (base_binfo,
1304                                  VF_BASETYPE_VALUE (vfields),
1305                                  CLASSTYPE_VFIELDS (t));
1306             }
1307         }
1308     }
1309
1310   if (!TYPE_VFIELD (t))
1311     CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
1312
1313   /* Find the indirect primary bases - those virtual bases which are primary
1314      bases of something else in this hierarchy.  */
1315   for (vbases = CLASSTYPE_VBASECLASSES (t);
1316        vbases;
1317        vbases = TREE_CHAIN (vbases))
1318     {
1319       tree vbase_binfo = TREE_VALUE (vbases);
1320
1321       /* See if this virtual base is an indirect primary base.  To be so,
1322          it must be a primary base within the hierarchy of one of our
1323          direct bases.  */
1324       for (i = 0; i < n_baseclasses; ++i)
1325         {
1326           tree basetype = TYPE_BINFO_BASETYPE (t, i);
1327           tree v;
1328
1329           for (v = CLASSTYPE_VBASECLASSES (basetype);
1330                v;
1331                v = TREE_CHAIN (v))
1332             {
1333               tree base_vbase = TREE_VALUE (v);
1334
1335               if (BINFO_PRIMARY_P (base_vbase)
1336                   && same_type_p (BINFO_TYPE (base_vbase),
1337                                   BINFO_TYPE (vbase_binfo)))
1338                 {
1339                   BINFO_INDIRECT_PRIMARY_P (vbase_binfo) = 1;
1340                   break;
1341                 }
1342             }
1343
1344           /* If we've discovered that this virtual base is an indirect
1345              primary base, then we can move on to the next virtual
1346              base.  */
1347           if (BINFO_INDIRECT_PRIMARY_P (vbase_binfo))
1348             break;
1349         }
1350     }
1351
1352   /* A "nearly-empty" virtual base class can be the primary base
1353      class, if no non-virtual polymorphic base can be found.  */
1354   if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
1355     {
1356       /* If not NULL, this is the best primary base candidate we have
1357          found so far.  */
1358       tree candidate = NULL_TREE;
1359       tree base_binfo;
1360
1361       /* Loop over the baseclasses.  */
1362       for (base_binfo = TYPE_BINFO (t);
1363            base_binfo;
1364            base_binfo = TREE_CHAIN (base_binfo))
1365         {
1366           tree basetype = BINFO_TYPE (base_binfo);
1367
1368           if (TREE_VIA_VIRTUAL (base_binfo)
1369               && CLASSTYPE_NEARLY_EMPTY_P (basetype))
1370             {
1371               /* If this is not an indirect primary base, then it's
1372                  definitely our primary base.  */
1373               if (!BINFO_INDIRECT_PRIMARY_P (base_binfo))
1374                 {
1375                   candidate = base_binfo;
1376                   break;
1377                 }
1378
1379               /* If this is an indirect primary base, it still could be
1380                  our primary base -- unless we later find there's another
1381                  nearly-empty virtual base that isn't an indirect
1382                  primary base.  */
1383               if (!candidate)
1384                 candidate = base_binfo;
1385             }
1386         }
1387
1388       /* If we've got a primary base, use it.  */
1389       if (candidate)
1390         {
1391           set_primary_base (t, candidate);
1392           CLASSTYPE_VFIELDS (t)
1393             = copy_list (CLASSTYPE_VFIELDS (BINFO_TYPE (candidate)));
1394         }
1395     }
1396
1397   /* Mark the primary base classes at this point.  */
1398   mark_primary_bases (t);
1399 }
1400 \f
1401 /* Set memoizing fields and bits of T (and its variants) for later
1402    use.  */
1403
1404 static void
1405 finish_struct_bits (tree t)
1406 {
1407   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1408
1409   /* Fix up variants (if any).  */
1410   tree variants = TYPE_NEXT_VARIANT (t);
1411   while (variants)
1412     {
1413       /* These fields are in the _TYPE part of the node, not in
1414          the TYPE_LANG_SPECIFIC component, so they are not shared.  */
1415       TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t);
1416       TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t);
1417       TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1418       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants)
1419         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
1420
1421       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (variants)
1422         = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t);
1423       TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t);
1424       TYPE_USES_VIRTUAL_BASECLASSES (variants) = TYPE_USES_VIRTUAL_BASECLASSES (t);
1425       /* Copy whatever these are holding today.  */
1426       TYPE_MIN_VALUE (variants) = TYPE_MIN_VALUE (t);
1427       TYPE_MAX_VALUE (variants) = TYPE_MAX_VALUE (t);
1428       TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1429       TYPE_SIZE (variants) = TYPE_SIZE (t);
1430       TYPE_SIZE_UNIT (variants) = TYPE_SIZE_UNIT (t);
1431       variants = TYPE_NEXT_VARIANT (variants);
1432     }
1433
1434   if (n_baseclasses && TYPE_POLYMORPHIC_P (t))
1435     /* For a class w/o baseclasses, `finish_struct' has set
1436        CLASS_TYPE_ABSTRACT_VIRTUALS correctly (by
1437        definition). Similarly for a class whose base classes do not
1438        have vtables. When neither of these is true, we might have
1439        removed abstract virtuals (by providing a definition), added
1440        some (by declaring new ones), or redeclared ones from a base
1441        class. We need to recalculate what's really an abstract virtual
1442        at this point (by looking in the vtables).  */
1443       get_pure_virtuals (t);
1444
1445   if (n_baseclasses)
1446     {
1447       /* Notice whether this class has type conversion functions defined.  */
1448       tree binfo = TYPE_BINFO (t);
1449       tree binfos = BINFO_BASETYPES (binfo);
1450       tree basetype;
1451
1452       for (i = n_baseclasses-1; i >= 0; i--)
1453         {
1454           basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
1455
1456           TYPE_HAS_CONVERSION (t) |= TYPE_HAS_CONVERSION (basetype);
1457         }
1458     }
1459
1460   /* If this type has a copy constructor or a destructor, force its mode to
1461      be BLKmode, and force its TREE_ADDRESSABLE bit to be nonzero.  This
1462      will cause it to be passed by invisible reference and prevent it from
1463      being returned in a register.  */
1464   if (! TYPE_HAS_TRIVIAL_INIT_REF (t) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
1465     {
1466       tree variants;
1467       DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1468       for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1469         {
1470           TYPE_MODE (variants) = BLKmode;
1471           TREE_ADDRESSABLE (variants) = 1;
1472         }
1473     }
1474 }
1475
1476 /* Issue warnings about T having private constructors, but no friends,
1477    and so forth.
1478
1479    HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1480    static members.  HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1481    non-private static member functions.  */
1482
1483 static void
1484 maybe_warn_about_overly_private_class (tree t)
1485 {
1486   int has_member_fn = 0;
1487   int has_nonprivate_method = 0;
1488   tree fn;
1489
1490   if (!warn_ctor_dtor_privacy
1491       /* If the class has friends, those entities might create and
1492          access instances, so we should not warn.  */
1493       || (CLASSTYPE_FRIEND_CLASSES (t)
1494           || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))
1495       /* We will have warned when the template was declared; there's
1496          no need to warn on every instantiation.  */
1497       || CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1498     /* There's no reason to even consider warning about this
1499        class.  */
1500     return;
1501
1502   /* We only issue one warning, if more than one applies, because
1503      otherwise, on code like:
1504
1505      class A {
1506        // Oops - forgot `public:'
1507        A();
1508        A(const A&);
1509        ~A();
1510      };
1511
1512      we warn several times about essentially the same problem.  */
1513
1514   /* Check to see if all (non-constructor, non-destructor) member
1515      functions are private.  (Since there are no friends or
1516      non-private statics, we can't ever call any of the private member
1517      functions.)  */
1518   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
1519     /* We're not interested in compiler-generated methods; they don't
1520        provide any way to call private members.  */
1521     if (!DECL_ARTIFICIAL (fn))
1522       {
1523         if (!TREE_PRIVATE (fn))
1524           {
1525             if (DECL_STATIC_FUNCTION_P (fn))
1526               /* A non-private static member function is just like a
1527                  friend; it can create and invoke private member
1528                  functions, and be accessed without a class
1529                  instance.  */
1530               return;
1531
1532             has_nonprivate_method = 1;
1533             /* Keep searching for a static member function.  */
1534           }
1535         else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn))
1536           has_member_fn = 1;
1537       }
1538
1539   if (!has_nonprivate_method && has_member_fn)
1540     {
1541       /* There are no non-private methods, and there's at least one
1542          private member function that isn't a constructor or
1543          destructor.  (If all the private members are
1544          constructors/destructors we want to use the code below that
1545          issues error messages specifically referring to
1546          constructors/destructors.)  */
1547       int i;
1548       tree binfo = TYPE_BINFO (t);
1549
1550       for (i = 0; i < BINFO_N_BASETYPES (binfo); i++)
1551         if (BINFO_BASEACCESS (binfo, i) != access_private_node)
1552           {
1553             has_nonprivate_method = 1;
1554             break;
1555           }
1556       if (!has_nonprivate_method)
1557         {
1558           warning ("all member functions in class `%T' are private", t);
1559           return;
1560         }
1561     }
1562
1563   /* Even if some of the member functions are non-private, the class
1564      won't be useful for much if all the constructors or destructors
1565      are private: such an object can never be created or destroyed.  */
1566   if (TYPE_HAS_DESTRUCTOR (t)
1567       && TREE_PRIVATE (CLASSTYPE_DESTRUCTORS (t)))
1568     {
1569       warning ("`%#T' only defines a private destructor and has no friends",
1570                t);
1571       return;
1572     }
1573
1574   if (TYPE_HAS_CONSTRUCTOR (t))
1575     {
1576       int nonprivate_ctor = 0;
1577
1578       /* If a non-template class does not define a copy
1579          constructor, one is defined for it, enabling it to avoid
1580          this warning.  For a template class, this does not
1581          happen, and so we would normally get a warning on:
1582
1583            template <class T> class C { private: C(); };
1584
1585          To avoid this asymmetry, we check TYPE_HAS_INIT_REF.  All
1586          complete non-template or fully instantiated classes have this
1587          flag set.  */
1588       if (!TYPE_HAS_INIT_REF (t))
1589         nonprivate_ctor = 1;
1590       else
1591         for (fn = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0);
1592              fn;
1593              fn = OVL_NEXT (fn))
1594           {
1595             tree ctor = OVL_CURRENT (fn);
1596             /* Ideally, we wouldn't count copy constructors (or, in
1597                fact, any constructor that takes an argument of the
1598                class type as a parameter) because such things cannot
1599                be used to construct an instance of the class unless
1600                you already have one.  But, for now at least, we're
1601                more generous.  */
1602             if (! TREE_PRIVATE (ctor))
1603               {
1604                 nonprivate_ctor = 1;
1605                 break;
1606               }
1607           }
1608
1609       if (nonprivate_ctor == 0)
1610         {
1611           warning ("`%#T' only defines private constructors and has no friends",
1612                       t);
1613           return;
1614         }
1615     }
1616 }
1617
1618 static struct {
1619   gt_pointer_operator new_value;
1620   void *cookie;
1621 } resort_data;
1622
1623 /* Comparison function to compare two TYPE_METHOD_VEC entries by name.  */
1624
1625 static int
1626 method_name_cmp (const void* m1_p, const void* m2_p)
1627 {
1628   const tree *const m1 = m1_p;
1629   const tree *const m2 = m2_p;
1630
1631   if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1632     return 0;
1633   if (*m1 == NULL_TREE)
1634     return -1;
1635   if (*m2 == NULL_TREE)
1636     return 1;
1637   if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2)))
1638     return -1;
1639   return 1;
1640 }
1641
1642 /* This routine compares two fields like method_name_cmp but using the
1643    pointer operator in resort_field_decl_data.  */
1644
1645 static int
1646 resort_method_name_cmp (const void* m1_p, const void* m2_p)
1647 {
1648   const tree *const m1 = m1_p;
1649   const tree *const m2 = m2_p;
1650   if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1651     return 0;
1652   if (*m1 == NULL_TREE)
1653     return -1;
1654   if (*m2 == NULL_TREE)
1655     return 1;
1656   {
1657     tree d1 = DECL_NAME (OVL_CURRENT (*m1));
1658     tree d2 = DECL_NAME (OVL_CURRENT (*m2));
1659     resort_data.new_value (&d1, resort_data.cookie);
1660     resort_data.new_value (&d2, resort_data.cookie);
1661     if (d1 < d2)
1662       return -1;
1663   }
1664   return 1;
1665 }
1666
1667 /* Resort TYPE_METHOD_VEC because pointers have been reordered.  */
1668
1669 void
1670 resort_type_method_vec (void* obj,
1671                         void* orig_obj ATTRIBUTE_UNUSED ,
1672                         gt_pointer_operator new_value,
1673                         void* cookie)
1674 {
1675   tree method_vec = obj;
1676   int len = TREE_VEC_LENGTH (method_vec);
1677   int slot;
1678
1679   /* The type conversion ops have to live at the front of the vec, so we
1680      can't sort them.  */
1681   for (slot = 2; slot < len; ++slot)
1682     {
1683       tree fn = TREE_VEC_ELT (method_vec, slot);
1684
1685       if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1686         break;
1687     }
1688   if (len - slot > 1)
1689     {
1690       resort_data.new_value = new_value;
1691       resort_data.cookie = cookie;
1692       qsort (&TREE_VEC_ELT (method_vec, slot), len - slot, sizeof (tree),
1693              resort_method_name_cmp);
1694     }
1695 }
1696
1697 /* Warn about duplicate methods in fn_fields.  Also compact method
1698    lists so that lookup can be made faster.
1699
1700    Data Structure: List of method lists.  The outer list is a
1701    TREE_LIST, whose TREE_PURPOSE field is the field name and the
1702    TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs.  TREE_CHAIN
1703    links the entire list of methods for TYPE_METHODS.  Friends are
1704    chained in the same way as member functions (? TREE_CHAIN or
1705    DECL_CHAIN), but they live in the TREE_TYPE field of the outer
1706    list.  That allows them to be quickly deleted, and requires no
1707    extra storage.
1708
1709    Sort methods that are not special (i.e., constructors, destructors,
1710    and type conversion operators) so that we can find them faster in
1711    search.  */
1712
1713 static void
1714 finish_struct_methods (tree t)
1715 {
1716   tree fn_fields;
1717   tree method_vec;
1718   int slot, len;
1719
1720   if (!TYPE_METHODS (t))
1721     {
1722       /* Clear these for safety; perhaps some parsing error could set
1723          these incorrectly.  */
1724       TYPE_HAS_CONSTRUCTOR (t) = 0;
1725       TYPE_HAS_DESTRUCTOR (t) = 0;
1726       CLASSTYPE_METHOD_VEC (t) = NULL_TREE;
1727       return;
1728     }
1729
1730   method_vec = CLASSTYPE_METHOD_VEC (t);
1731   my_friendly_assert (method_vec != NULL_TREE, 19991215);
1732   len = TREE_VEC_LENGTH (method_vec);
1733
1734   /* First fill in entry 0 with the constructors, entry 1 with destructors,
1735      and the next few with type conversion operators (if any).  */
1736   for (fn_fields = TYPE_METHODS (t); fn_fields;
1737        fn_fields = TREE_CHAIN (fn_fields))
1738     /* Clear out this flag.  */
1739     DECL_IN_AGGR_P (fn_fields) = 0;
1740
1741   if (TYPE_HAS_DESTRUCTOR (t) && !CLASSTYPE_DESTRUCTORS (t))
1742     /* We thought there was a destructor, but there wasn't.  Some
1743        parse errors cause this anomalous situation.  */
1744     TYPE_HAS_DESTRUCTOR (t) = 0;
1745
1746   /* Issue warnings about private constructors and such.  If there are
1747      no methods, then some public defaults are generated.  */
1748   maybe_warn_about_overly_private_class (t);
1749
1750   /* Now sort the methods.  */
1751   while (len > 2 && TREE_VEC_ELT (method_vec, len-1) == NULL_TREE)
1752     len--;
1753   TREE_VEC_LENGTH (method_vec) = len;
1754
1755   /* The type conversion ops have to live at the front of the vec, so we
1756      can't sort them.  */
1757   for (slot = 2; slot < len; ++slot)
1758     {
1759       tree fn = TREE_VEC_ELT (method_vec, slot);
1760
1761       if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1762         break;
1763     }
1764   if (len - slot > 1)
1765     qsort (&TREE_VEC_ELT (method_vec, slot), len-slot, sizeof (tree),
1766            method_name_cmp);
1767 }
1768
1769 /* Make BINFO's vtable have N entries, including RTTI entries,
1770    vbase and vcall offsets, etc.  Set its type and call the backend
1771    to lay it out.  */
1772
1773 static void
1774 layout_vtable_decl (tree binfo, int n)
1775 {
1776   tree atype;
1777   tree vtable;
1778
1779   atype = build_cplus_array_type (vtable_entry_type,
1780                                   build_index_type (size_int (n - 1)));
1781   layout_type (atype);
1782
1783   /* We may have to grow the vtable.  */
1784   vtable = get_vtbl_decl_for_binfo (binfo);
1785   if (!same_type_p (TREE_TYPE (vtable), atype))
1786     {
1787       TREE_TYPE (vtable) = atype;
1788       DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE;
1789       layout_decl (vtable, 0);
1790     }
1791 }
1792
1793 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1794    have the same signature.  */
1795
1796 int
1797 same_signature_p (tree fndecl, tree base_fndecl)
1798 {
1799   /* One destructor overrides another if they are the same kind of
1800      destructor.  */
1801   if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl)
1802       && special_function_p (base_fndecl) == special_function_p (fndecl))
1803     return 1;
1804   /* But a non-destructor never overrides a destructor, nor vice
1805      versa, nor do different kinds of destructors override
1806      one-another.  For example, a complete object destructor does not
1807      override a deleting destructor.  */
1808   if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl))
1809     return 0;
1810
1811   if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl)
1812       || (DECL_CONV_FN_P (fndecl)
1813           && DECL_CONV_FN_P (base_fndecl)
1814           && same_type_p (DECL_CONV_FN_TYPE (fndecl),
1815                           DECL_CONV_FN_TYPE (base_fndecl))))
1816     {
1817       tree types, base_types;
1818       types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1819       base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
1820       if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types)))
1821            == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types))))
1822           && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types)))
1823         return 1;
1824     }
1825   return 0;
1826 }
1827
1828 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1829    subobject.  */
1830
1831 static bool
1832 base_derived_from (tree derived, tree base)
1833 {
1834   tree probe;
1835
1836   for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1837     {
1838       if (probe == derived)
1839         return true;
1840       else if (TREE_VIA_VIRTUAL (probe))
1841         /* If we meet a virtual base, we can't follow the inheritance
1842            any more.  See if the complete type of DERIVED contains
1843            such a virtual base.  */
1844         return purpose_member (BINFO_TYPE (probe),
1845                                CLASSTYPE_VBASECLASSES (BINFO_TYPE (derived)))
1846           != NULL_TREE;
1847     }
1848   return false;
1849 }
1850
1851 typedef struct count_depth_data {
1852   /* The depth of the current subobject, with "1" as the depth of the
1853      most derived object in the hierarchy.  */
1854   size_t depth;
1855   /* The maximum depth found so far.  */
1856   size_t max_depth;
1857 } count_depth_data;
1858
1859 /* Called from find_final_overrider via dfs_walk.  */
1860
1861 static tree
1862 dfs_depth_post (tree binfo ATTRIBUTE_UNUSED, void *data)
1863 {
1864   count_depth_data *cd = (count_depth_data *) data;
1865   if (cd->depth > cd->max_depth)
1866     cd->max_depth = cd->depth;
1867   cd->depth--;
1868   return NULL_TREE;
1869 }
1870
1871 /* Called from find_final_overrider via dfs_walk.  */
1872
1873 static tree
1874 dfs_depth_q (tree derived, int i, void *data)
1875 {
1876   count_depth_data *cd = (count_depth_data *) data;
1877   cd->depth++;
1878   return BINFO_BASETYPE (derived, i);
1879 }
1880
1881 typedef struct find_final_overrider_data_s {
1882   /* The function for which we are trying to find a final overrider.  */
1883   tree fn;
1884   /* The base class in which the function was declared.  */
1885   tree declaring_base;
1886   /* The most derived class in the hierarchy.  */
1887   tree most_derived_type;
1888   /* The candidate overriders.  */
1889   tree candidates;
1890   /* Each entry in this array is the next-most-derived class for a
1891      virtual base class along the current path.  */
1892   tree *vpath_list;
1893   /* A pointer one past the top of the VPATH_LIST.  */
1894   tree *vpath;
1895 } find_final_overrider_data;
1896
1897 /* Add the overrider along the current path to FFOD->CANDIDATES.
1898    Returns true if an overrider was found; false otherwise.  */
1899
1900 static bool
1901 dfs_find_final_overrider_1 (tree binfo,
1902                             tree *vpath,
1903                             find_final_overrider_data *ffod)
1904 {
1905   tree method;
1906
1907   /* If BINFO is not the most derived type, try a more derived class.
1908      A definition there will overrider a definition here.  */
1909   if (!same_type_p (BINFO_TYPE (binfo), ffod->most_derived_type))
1910     {
1911       tree derived;
1912
1913       if (TREE_VIA_VIRTUAL (binfo))
1914         derived = *--vpath;
1915       else
1916         derived = BINFO_INHERITANCE_CHAIN (binfo);
1917       if (dfs_find_final_overrider_1 (derived, vpath, ffod))
1918         return true;
1919     }
1920
1921   method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
1922   if (method)
1923     {
1924       tree *candidate = &ffod->candidates;
1925
1926       /* Remove any candidates overridden by this new function.  */
1927       while (*candidate)
1928         {
1929           /* If *CANDIDATE overrides METHOD, then METHOD
1930              cannot override anything else on the list.  */
1931           if (base_derived_from (TREE_VALUE (*candidate), binfo))
1932             return true;
1933           /* If METHOD overrides *CANDIDATE, remove *CANDIDATE.  */
1934           if (base_derived_from (binfo, TREE_VALUE (*candidate)))
1935             *candidate = TREE_CHAIN (*candidate);
1936           else
1937             candidate = &TREE_CHAIN (*candidate);
1938         }
1939
1940       /* Add the new function.  */
1941       ffod->candidates = tree_cons (method, binfo, ffod->candidates);
1942       return true;
1943     }
1944
1945   return false;
1946 }
1947
1948 /* Called from find_final_overrider via dfs_walk.  */
1949
1950 static tree
1951 dfs_find_final_overrider (tree binfo, void* data)
1952 {
1953   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1954
1955   if (binfo == ffod->declaring_base)
1956     dfs_find_final_overrider_1 (binfo, ffod->vpath, ffod);
1957
1958   return NULL_TREE;
1959 }
1960
1961 static tree
1962 dfs_find_final_overrider_q (tree derived, int ix, void *data)
1963 {
1964   tree binfo = BINFO_BASETYPE (derived, ix);
1965   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1966
1967   if (TREE_VIA_VIRTUAL (binfo))
1968     *ffod->vpath++ = derived;
1969
1970   return binfo;
1971 }
1972
1973 static tree
1974 dfs_find_final_overrider_post (tree binfo, void *data)
1975 {
1976   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1977
1978   if (TREE_VIA_VIRTUAL (binfo))
1979     ffod->vpath--;
1980
1981   return NULL_TREE;
1982 }
1983
1984 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1985    FN and whose TREE_VALUE is the binfo for the base where the
1986    overriding occurs.  BINFO (in the hierarchy dominated by the binfo
1987    DERIVED) is the base object in which FN is declared.  */
1988
1989 static tree
1990 find_final_overrider (tree derived, tree binfo, tree fn)
1991 {
1992   find_final_overrider_data ffod;
1993   count_depth_data cd;
1994
1995   /* Getting this right is a little tricky.  This is valid:
1996
1997        struct S { virtual void f (); };
1998        struct T { virtual void f (); };
1999        struct U : public S, public T { };
2000
2001      even though calling `f' in `U' is ambiguous.  But,
2002
2003        struct R { virtual void f(); };
2004        struct S : virtual public R { virtual void f (); };
2005        struct T : virtual public R { virtual void f (); };
2006        struct U : public S, public T { };
2007
2008      is not -- there's no way to decide whether to put `S::f' or
2009      `T::f' in the vtable for `R'.
2010
2011      The solution is to look at all paths to BINFO.  If we find
2012      different overriders along any two, then there is a problem.  */
2013   if (DECL_THUNK_P (fn))
2014     fn = THUNK_TARGET (fn);
2015
2016   /* Determine the depth of the hierarchy.  */
2017   cd.depth = 0;
2018   cd.max_depth = 0;
2019   dfs_walk (derived, dfs_depth_post, dfs_depth_q, &cd);
2020
2021   ffod.fn = fn;
2022   ffod.declaring_base = binfo;
2023   ffod.most_derived_type = BINFO_TYPE (derived);
2024   ffod.candidates = NULL_TREE;
2025   ffod.vpath_list = (tree *) xcalloc (cd.max_depth, sizeof (tree));
2026   ffod.vpath = ffod.vpath_list;
2027
2028   dfs_walk_real (derived,
2029                  dfs_find_final_overrider,
2030                  dfs_find_final_overrider_post,
2031                  dfs_find_final_overrider_q,
2032                  &ffod);
2033
2034   free (ffod.vpath_list);
2035
2036   /* If there was no winner, issue an error message.  */
2037   if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
2038     {
2039       error ("no unique final overrider for `%D' in `%T'", fn,
2040              BINFO_TYPE (derived));
2041       return error_mark_node;
2042     }
2043
2044   return ffod.candidates;
2045 }
2046
2047 /* Return the index of the vcall offset for FN when TYPE is used as a
2048    virtual base.  */
2049
2050 static tree
2051 get_vcall_index (tree fn, tree type)
2052 {
2053   tree v;
2054
2055   for (v = CLASSTYPE_VCALL_INDICES (type); v; v = TREE_CHAIN (v))
2056     if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (TREE_PURPOSE (v)))
2057         || same_signature_p (fn, TREE_PURPOSE (v)))
2058       break;
2059
2060   /* There should always be an appropriate index.  */
2061   my_friendly_assert (v, 20021103);
2062
2063   return TREE_VALUE (v);
2064 }
2065
2066 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2067    dominated by T.  FN has been overridden in BINFO; VIRTUALS points to the
2068    corresponding position in the BINFO_VIRTUALS list.  */
2069
2070 static void
2071 update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
2072                             unsigned ix)
2073 {
2074   tree b;
2075   tree overrider;
2076   tree delta;
2077   tree virtual_base;
2078   tree first_defn;
2079   tree overrider_fn, overrider_target;
2080   tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn;
2081   tree over_return, base_return;
2082   bool lost = false;
2083
2084   /* Find the nearest primary base (possibly binfo itself) which defines
2085      this function; this is the class the caller will convert to when
2086      calling FN through BINFO.  */
2087   for (b = binfo; ; b = get_primary_binfo (b))
2088     {
2089       my_friendly_assert (b, 20021227);
2090       if (look_for_overrides_here (BINFO_TYPE (b), target_fn))
2091         break;
2092
2093       /* The nearest definition is from a lost primary.  */
2094       if (BINFO_LOST_PRIMARY_P (b))
2095         lost = true;
2096     }
2097   first_defn = b;
2098
2099   /* Find the final overrider.  */
2100   overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn);
2101   if (overrider == error_mark_node)
2102     return;
2103   overrider_target = overrider_fn = TREE_PURPOSE (overrider);
2104
2105   /* Check for adjusting covariant return types.  */
2106   over_return = TREE_TYPE (TREE_TYPE (overrider_target));
2107   base_return = TREE_TYPE (TREE_TYPE (target_fn));
2108
2109   if (POINTER_TYPE_P (over_return)
2110       && TREE_CODE (over_return) == TREE_CODE (base_return)
2111       && CLASS_TYPE_P (TREE_TYPE (over_return))
2112       && CLASS_TYPE_P (TREE_TYPE (base_return)))
2113     {
2114       /* If FN is a covariant thunk, we must figure out the adjustment
2115          to the final base FN was converting to. As OVERRIDER_TARGET might
2116          also be converting to the return type of FN, we have to
2117          combine the two conversions here.  */
2118       tree fixed_offset, virtual_offset;
2119
2120       over_return = TREE_TYPE (over_return);
2121       base_return = TREE_TYPE (base_return);
2122
2123       if (DECL_THUNK_P (fn))
2124         {
2125           my_friendly_assert (DECL_RESULT_THUNK_P (fn), 20031211);
2126           fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn));
2127           virtual_offset = THUNK_VIRTUAL_OFFSET (fn);
2128         }
2129       else
2130         fixed_offset = virtual_offset = NULL_TREE;
2131
2132       if (virtual_offset)
2133         /* Find the equivalent binfo within the return type of the
2134            overriding function. We will want the vbase offset from
2135            there.  */
2136         virtual_offset =
2137           TREE_VALUE (purpose_member
2138                       (BINFO_TYPE (virtual_offset),
2139                        CLASSTYPE_VBASECLASSES (over_return)));
2140       else if (!same_type_ignoring_top_level_qualifiers_p
2141                (over_return, base_return))
2142         {
2143           /* There was no existing virtual thunk (which takes
2144              precedence).  So find the binfo of the base function's
2145              return type within the overriding function's return type.
2146              We cannot call lookup base here, because we're inside a
2147              dfs_walk, and will therefore clobber the BINFO_MARKED
2148              flags.  Fortunately we know the covariancy is valid (it
2149              has already been checked), so we can just iterate along
2150              the binfos, which have been chained in inheritance graph
2151              order.  Of course it is lame that we have to repeat the
2152              search here anyway -- we should really be caching pieces
2153              of the vtable and avoiding this repeated work.  */
2154           tree thunk_binfo, base_binfo;
2155
2156           /* Find the base binfo within the overriding function's
2157              return type.  We will always find a thunk_binfo, except
2158              when the covariancy is invalid (which we will have
2159              already diagnosed).  */
2160           for (base_binfo = TYPE_BINFO (base_return),
2161                thunk_binfo = TYPE_BINFO (over_return);
2162                thunk_binfo;
2163                thunk_binfo = TREE_CHAIN (thunk_binfo))
2164             if (same_type_p (BINFO_TYPE (thunk_binfo),
2165                              BINFO_TYPE (base_binfo)))
2166               break;
2167
2168           /* See if virtual inheritance is involved.  */
2169           for (virtual_offset = thunk_binfo;
2170                virtual_offset;
2171                virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset))
2172             if (TREE_VIA_VIRTUAL (virtual_offset))
2173               break;
2174
2175           if (virtual_offset
2176               || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo)))
2177             {
2178               tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2179
2180               if (virtual_offset)
2181                 {
2182                   /* We convert via virtual base.  Adjust the fixed
2183                      offset to be from there.  */
2184                   offset = size_diffop
2185                     (offset, convert
2186                      (ssizetype, BINFO_OFFSET (virtual_offset)));
2187                 }
2188               if (fixed_offset)
2189                 /* There was an existing fixed offset, this must be
2190                    from the base just converted to, and the base the
2191                    FN was thunking to.  */
2192                 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2193               else
2194                 fixed_offset = offset;
2195             }
2196         }
2197
2198       if (fixed_offset || virtual_offset)
2199         /* Replace the overriding function with a covariant thunk.  We
2200            will emit the overriding function in its own slot as
2201            well.  */
2202         overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0,
2203                                    fixed_offset, virtual_offset);
2204     }
2205   else
2206     my_friendly_assert (!DECL_THUNK_P (fn), 20021231);
2207
2208   /* Assume that we will produce a thunk that convert all the way to
2209      the final overrider, and not to an intermediate virtual base.  */
2210   virtual_base = NULL_TREE;
2211
2212   /* See if we can convert to an intermediate virtual base first, and then
2213      use the vcall offset located there to finish the conversion.  */
2214   for (; b; b = BINFO_INHERITANCE_CHAIN (b))
2215     {
2216       /* If we find the final overrider, then we can stop
2217          walking.  */
2218       if (same_type_p (BINFO_TYPE (b),
2219                        BINFO_TYPE (TREE_VALUE (overrider))))
2220         break;
2221
2222       /* If we find a virtual base, and we haven't yet found the
2223          overrider, then there is a virtual base between the
2224          declaring base (first_defn) and the final overrider.  */
2225       if (TREE_VIA_VIRTUAL (b))
2226         {
2227           virtual_base = b;
2228           break;
2229         }
2230     }
2231
2232   if (overrider_fn != overrider_target && !virtual_base)
2233     {
2234       /* The ABI specifies that a covariant thunk includes a mangling
2235          for a this pointer adjustment.  This-adjusting thunks that
2236          override a function from a virtual base have a vcall
2237          adjustment.  When the virtual base in question is a primary
2238          virtual base, we know the adjustments are zero, (and in the
2239          non-covariant case, we would not use the thunk).
2240          Unfortunately we didn't notice this could happen, when
2241          designing the ABI and so never mandated that such a covariant
2242          thunk should be emitted.  Because we must use the ABI mandated
2243          name, we must continue searching from the binfo where we
2244          found the most recent definition of the function, towards the
2245          primary binfo which first introduced the function into the
2246          vtable.  If that enters a virtual base, we must use a vcall
2247          this-adjusting thunk.  Bleah! */
2248       tree probe = first_defn;
2249
2250       while ((probe = get_primary_binfo (probe))
2251              && (unsigned) list_length (BINFO_VIRTUALS (probe)) > ix)
2252         if (TREE_VIA_VIRTUAL (probe))
2253           virtual_base = probe;
2254
2255       if (virtual_base)
2256         /* Even if we find a virtual base, the correct delta is
2257            between the overrider and the binfo we're building a vtable
2258            for.  */
2259         goto virtual_covariant;
2260     }
2261
2262   /* Compute the constant adjustment to the `this' pointer.  The
2263      `this' pointer, when this function is called, will point at BINFO
2264      (or one of its primary bases, which are at the same offset).  */
2265   if (virtual_base)
2266     /* The `this' pointer needs to be adjusted from the declaration to
2267        the nearest virtual base.  */
2268     delta = size_diffop (convert (ssizetype, BINFO_OFFSET (virtual_base)),
2269                          convert (ssizetype, BINFO_OFFSET (first_defn)));
2270   else if (lost)
2271     /* If the nearest definition is in a lost primary, we don't need an
2272        entry in our vtable.  Except possibly in a constructor vtable,
2273        if we happen to get our primary back.  In that case, the offset
2274        will be zero, as it will be a primary base.  */
2275     delta = size_zero_node;
2276   else
2277     /* The `this' pointer needs to be adjusted from pointing to
2278        BINFO to pointing at the base where the final overrider
2279        appears.  */
2280     virtual_covariant:
2281     delta = size_diffop (convert (ssizetype,
2282                                   BINFO_OFFSET (TREE_VALUE (overrider))),
2283                          convert (ssizetype, BINFO_OFFSET (binfo)));
2284
2285   modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals);
2286
2287   if (virtual_base)
2288     BV_VCALL_INDEX (*virtuals)
2289       = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base));
2290 }
2291
2292 /* Called from modify_all_vtables via dfs_walk.  */
2293
2294 static tree
2295 dfs_modify_vtables (tree binfo, void* data)
2296 {
2297   if (/* There's no need to modify the vtable for a non-virtual
2298          primary base; we're not going to use that vtable anyhow.
2299          We do still need to do this for virtual primary bases, as they
2300          could become non-primary in a construction vtable.  */
2301       (!BINFO_PRIMARY_P (binfo) || TREE_VIA_VIRTUAL (binfo))
2302       /* Similarly, a base without a vtable needs no modification.  */
2303       && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2304     {
2305       tree t = (tree) data;
2306       tree virtuals;
2307       tree old_virtuals;
2308       unsigned ix;
2309
2310       make_new_vtable (t, binfo);
2311
2312       /* Now, go through each of the virtual functions in the virtual
2313          function table for BINFO.  Find the final overrider, and
2314          update the BINFO_VIRTUALS list appropriately.  */
2315       for (ix = 0, virtuals = BINFO_VIRTUALS (binfo),
2316              old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
2317            virtuals;
2318            ix++, virtuals = TREE_CHAIN (virtuals),
2319              old_virtuals = TREE_CHAIN (old_virtuals))
2320         update_vtable_entry_for_fn (t,
2321                                     binfo,
2322                                     BV_FN (old_virtuals),
2323                                     &virtuals, ix);
2324     }
2325
2326   BINFO_MARKED (binfo) = 1;
2327
2328   return NULL_TREE;
2329 }
2330
2331 /* Update all of the primary and secondary vtables for T.  Create new
2332    vtables as required, and initialize their RTTI information.  Each
2333    of the functions in VIRTUALS is declared in T and may override a
2334    virtual function from a base class; find and modify the appropriate
2335    entries to point to the overriding functions.  Returns a list, in
2336    declaration order, of the virtual functions that are declared in T,
2337    but do not appear in the primary base class vtable, and which
2338    should therefore be appended to the end of the vtable for T.  */
2339
2340 static tree
2341 modify_all_vtables (tree t, tree virtuals)
2342 {
2343   tree binfo = TYPE_BINFO (t);
2344   tree *fnsp;
2345
2346   /* Update all of the vtables.  */
2347   dfs_walk (binfo, dfs_modify_vtables, unmarkedp, t);
2348   dfs_walk (binfo, dfs_unmark, markedp, t);
2349
2350   /* Add virtual functions not already in our primary vtable. These
2351      will be both those introduced by this class, and those overridden
2352      from secondary bases.  It does not include virtuals merely
2353      inherited from secondary bases.  */
2354   for (fnsp = &virtuals; *fnsp; )
2355     {
2356       tree fn = TREE_VALUE (*fnsp);
2357
2358       if (!value_member (fn, BINFO_VIRTUALS (binfo))
2359           || DECL_VINDEX (fn) == error_mark_node)
2360         {
2361           /* We don't need to adjust the `this' pointer when
2362              calling this function.  */
2363           BV_DELTA (*fnsp) = integer_zero_node;
2364           BV_VCALL_INDEX (*fnsp) = NULL_TREE;
2365
2366           /* This is a function not already in our vtable.  Keep it.  */
2367           fnsp = &TREE_CHAIN (*fnsp);
2368         }
2369       else
2370         /* We've already got an entry for this function.  Skip it.  */
2371         *fnsp = TREE_CHAIN (*fnsp);
2372     }
2373
2374   return virtuals;
2375 }
2376
2377 /* Get the base virtual function declarations in T that have the
2378    indicated NAME.  */
2379
2380 static tree
2381 get_basefndecls (tree name, tree t)
2382 {
2383   tree methods;
2384   tree base_fndecls = NULL_TREE;
2385   int n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
2386   int i;
2387
2388   /* Find virtual functions in T with the indicated NAME.  */
2389   i = lookup_fnfields_1 (t, name);
2390   if (i != -1)
2391     for (methods = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), i);
2392          methods;
2393          methods = OVL_NEXT (methods))
2394       {
2395         tree method = OVL_CURRENT (methods);
2396
2397         if (TREE_CODE (method) == FUNCTION_DECL
2398             && DECL_VINDEX (method))
2399           base_fndecls = tree_cons (NULL_TREE, method, base_fndecls);
2400       }
2401
2402   if (base_fndecls)
2403     return base_fndecls;
2404
2405   for (i = 0; i < n_baseclasses; i++)
2406     {
2407       tree basetype = TYPE_BINFO_BASETYPE (t, i);
2408       base_fndecls = chainon (get_basefndecls (name, basetype),
2409                               base_fndecls);
2410     }
2411
2412   return base_fndecls;
2413 }
2414
2415 /* If this declaration supersedes the declaration of
2416    a method declared virtual in the base class, then
2417    mark this field as being virtual as well.  */
2418
2419 static void
2420 check_for_override (tree decl, tree ctype)
2421 {
2422   if (TREE_CODE (decl) == TEMPLATE_DECL)
2423     /* In [temp.mem] we have:
2424
2425          A specialization of a member function template does not
2426          override a virtual function from a base class.  */
2427     return;
2428   if ((DECL_DESTRUCTOR_P (decl)
2429        || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl))
2430        || DECL_CONV_FN_P (decl))
2431       && look_for_overrides (ctype, decl)
2432       && !DECL_STATIC_FUNCTION_P (decl))
2433     /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2434        the error_mark_node so that we know it is an overriding
2435        function.  */
2436     DECL_VINDEX (decl) = decl;
2437
2438   if (DECL_VIRTUAL_P (decl))
2439     {
2440       if (!DECL_VINDEX (decl))
2441         DECL_VINDEX (decl) = error_mark_node;
2442       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2443     }
2444 }
2445
2446 /* Warn about hidden virtual functions that are not overridden in t.
2447    We know that constructors and destructors don't apply.  */
2448
2449 void
2450 warn_hidden (tree t)
2451 {
2452   tree method_vec = CLASSTYPE_METHOD_VEC (t);
2453   int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
2454   int i;
2455
2456   /* We go through each separately named virtual function.  */
2457   for (i = 2; i < n_methods && TREE_VEC_ELT (method_vec, i); ++i)
2458     {
2459       tree fns;
2460       tree name;
2461       tree fndecl;
2462       tree base_fndecls;
2463       int j;
2464
2465       /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2466          have the same name.  Figure out what name that is.  */
2467       name = DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec, i)));
2468       /* There are no possibly hidden functions yet.  */
2469       base_fndecls = NULL_TREE;
2470       /* Iterate through all of the base classes looking for possibly
2471          hidden functions.  */
2472       for (j = 0; j < CLASSTYPE_N_BASECLASSES (t); j++)
2473         {
2474           tree basetype = TYPE_BINFO_BASETYPE (t, j);
2475           base_fndecls = chainon (get_basefndecls (name, basetype),
2476                                   base_fndecls);
2477         }
2478
2479       /* If there are no functions to hide, continue.  */
2480       if (!base_fndecls)
2481         continue;
2482
2483       /* Remove any overridden functions.  */
2484       for (fns = TREE_VEC_ELT (method_vec, i); fns; fns = OVL_NEXT (fns))
2485         {
2486           fndecl = OVL_CURRENT (fns);
2487           if (DECL_VINDEX (fndecl))
2488             {
2489               tree *prev = &base_fndecls;
2490
2491               while (*prev)
2492                 /* If the method from the base class has the same
2493                    signature as the method from the derived class, it
2494                    has been overridden.  */
2495                 if (same_signature_p (fndecl, TREE_VALUE (*prev)))
2496                   *prev = TREE_CHAIN (*prev);
2497                 else
2498                   prev = &TREE_CHAIN (*prev);
2499             }
2500         }
2501
2502       /* Now give a warning for all base functions without overriders,
2503          as they are hidden.  */
2504       while (base_fndecls)
2505         {
2506           /* Here we know it is a hider, and no overrider exists.  */
2507           cp_warning_at ("`%D' was hidden", TREE_VALUE (base_fndecls));
2508           cp_warning_at ("  by `%D'",
2509                          OVL_CURRENT (TREE_VEC_ELT (method_vec, i)));
2510           base_fndecls = TREE_CHAIN (base_fndecls);
2511         }
2512     }
2513 }
2514
2515 /* Check for things that are invalid.  There are probably plenty of other
2516    things we should check for also.  */
2517
2518 static void
2519 finish_struct_anon (tree t)
2520 {
2521   tree field;
2522
2523   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2524     {
2525       if (TREE_STATIC (field))
2526         continue;
2527       if (TREE_CODE (field) != FIELD_DECL)
2528         continue;
2529
2530       if (DECL_NAME (field) == NULL_TREE
2531           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2532         {
2533           tree elt = TYPE_FIELDS (TREE_TYPE (field));
2534           for (; elt; elt = TREE_CHAIN (elt))
2535             {
2536               /* We're generally only interested in entities the user
2537                  declared, but we also find nested classes by noticing
2538                  the TYPE_DECL that we create implicitly.  You're
2539                  allowed to put one anonymous union inside another,
2540                  though, so we explicitly tolerate that.  We use
2541                  TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2542                  we also allow unnamed types used for defining fields.  */
2543               if (DECL_ARTIFICIAL (elt)
2544                   && (!DECL_IMPLICIT_TYPEDEF_P (elt)
2545                       || TYPE_ANONYMOUS_P (TREE_TYPE (elt))))
2546                 continue;
2547
2548               if (TREE_CODE (elt) != FIELD_DECL)
2549                 {
2550                   cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members",
2551                                  elt);
2552                   continue;
2553                 }
2554
2555               if (TREE_PRIVATE (elt))
2556                 cp_pedwarn_at ("private member `%#D' in anonymous union",
2557                                elt);
2558               else if (TREE_PROTECTED (elt))
2559                 cp_pedwarn_at ("protected member `%#D' in anonymous union",
2560                                elt);
2561
2562               TREE_PRIVATE (elt) = TREE_PRIVATE (field);
2563               TREE_PROTECTED (elt) = TREE_PROTECTED (field);
2564             }
2565         }
2566     }
2567 }
2568
2569 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2570    will be used later during class template instantiation.
2571    When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2572    a non-static member data (FIELD_DECL), a member function
2573    (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2574    a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2575    When FRIEND_P is nonzero, T is either a friend class
2576    (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2577    (FUNCTION_DECL, TEMPLATE_DECL).  */
2578
2579 void
2580 maybe_add_class_template_decl_list (tree type, tree t, int friend_p)
2581 {
2582   /* Save some memory by not creating TREE_LIST if TYPE is not template.  */
2583   if (CLASSTYPE_TEMPLATE_INFO (type))
2584     CLASSTYPE_DECL_LIST (type)
2585       = tree_cons (friend_p ? NULL_TREE : type,
2586                    t, CLASSTYPE_DECL_LIST (type));
2587 }
2588
2589 /* Create default constructors, assignment operators, and so forth for
2590    the type indicated by T, if they are needed.
2591    CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
2592    CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the
2593    class cannot have a default constructor, copy constructor taking a
2594    const reference argument, or an assignment operator taking a const
2595    reference, respectively.  If a virtual destructor is created, its
2596    DECL is returned; otherwise the return value is NULL_TREE.  */
2597
2598 static void
2599 add_implicitly_declared_members (tree t,
2600                                  int cant_have_default_ctor,
2601                                  int cant_have_const_cctor,
2602                                  int cant_have_const_assignment)
2603 {
2604   tree default_fn;
2605   tree implicit_fns = NULL_TREE;
2606   tree virtual_dtor = NULL_TREE;
2607   tree *f;
2608
2609   ++adding_implicit_members;
2610
2611   /* Destructor.  */
2612   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t))
2613     {
2614       default_fn = implicitly_declare_fn (sfk_destructor, t, /*const_p=*/0);
2615       check_for_override (default_fn, t);
2616
2617       /* If we couldn't make it work, then pretend we didn't need it.  */
2618       if (default_fn == void_type_node)
2619         TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 0;
2620       else
2621         {
2622           TREE_CHAIN (default_fn) = implicit_fns;
2623           implicit_fns = default_fn;
2624
2625           if (DECL_VINDEX (default_fn))
2626             virtual_dtor = default_fn;
2627         }
2628     }
2629   else
2630     /* Any non-implicit destructor is non-trivial.  */
2631     TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t);
2632
2633   /* Default constructor.  */
2634   if (! TYPE_HAS_CONSTRUCTOR (t) && ! cant_have_default_ctor)
2635     {
2636       default_fn = implicitly_declare_fn (sfk_constructor, t, /*const_p=*/0);
2637       TREE_CHAIN (default_fn) = implicit_fns;
2638       implicit_fns = default_fn;
2639     }
2640
2641   /* Copy constructor.  */
2642   if (! TYPE_HAS_INIT_REF (t) && ! TYPE_FOR_JAVA (t))
2643     {
2644       /* ARM 12.18: You get either X(X&) or X(const X&), but
2645          not both.  --Chip  */
2646       default_fn
2647         = implicitly_declare_fn (sfk_copy_constructor, t,
2648                                  /*const_p=*/!cant_have_const_cctor);
2649       TREE_CHAIN (default_fn) = implicit_fns;
2650       implicit_fns = default_fn;
2651     }
2652
2653   /* Assignment operator.  */
2654   if (! TYPE_HAS_ASSIGN_REF (t) && ! TYPE_FOR_JAVA (t))
2655     {
2656       default_fn
2657         = implicitly_declare_fn (sfk_assignment_operator, t,
2658                                  /*const_p=*/!cant_have_const_assignment);
2659       TREE_CHAIN (default_fn) = implicit_fns;
2660       implicit_fns = default_fn;
2661     }
2662
2663   /* Now, hook all of the new functions on to TYPE_METHODS,
2664      and add them to the CLASSTYPE_METHOD_VEC.  */
2665   for (f = &implicit_fns; *f; f = &TREE_CHAIN (*f))
2666     {
2667       add_method (t, *f, /*error_p=*/0);
2668       maybe_add_class_template_decl_list (current_class_type, *f, /*friend_p=*/0);
2669     }
2670   if (abi_version_at_least (2))
2671     /* G++ 3.2 put the implicit destructor at the *beginning* of the
2672        list, which cause the destructor to be emitted in an incorrect
2673        location in the vtable.  */
2674     TYPE_METHODS (t) = chainon (TYPE_METHODS (t), implicit_fns);
2675   else
2676     {
2677       if (warn_abi && virtual_dtor)
2678         warning ("vtable layout for class `%T' may not be ABI-compliant "
2679                  "and may change in a future version of GCC due to implicit "
2680                  "virtual destructor",
2681                  t);
2682       *f = TYPE_METHODS (t);
2683       TYPE_METHODS (t) = implicit_fns;
2684     }
2685
2686   --adding_implicit_members;
2687 }
2688
2689 /* Subroutine of finish_struct_1.  Recursively count the number of fields
2690    in TYPE, including anonymous union members.  */
2691
2692 static int
2693 count_fields (tree fields)
2694 {
2695   tree x;
2696   int n_fields = 0;
2697   for (x = fields; x; x = TREE_CHAIN (x))
2698     {
2699       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2700         n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
2701       else
2702         n_fields += 1;
2703     }
2704   return n_fields;
2705 }
2706
2707 /* Subroutine of finish_struct_1.  Recursively add all the fields in the
2708    TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX.  */
2709
2710 static int
2711 add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx)
2712 {
2713   tree x;
2714   for (x = fields; x; x = TREE_CHAIN (x))
2715     {
2716       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2717         idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
2718       else
2719         field_vec->elts[idx++] = x;
2720     }
2721   return idx;
2722 }
2723
2724 /* FIELD is a bit-field.  We are finishing the processing for its
2725    enclosing type.  Issue any appropriate messages and set appropriate
2726    flags.  */
2727
2728 static void
2729 check_bitfield_decl (tree field)
2730 {
2731   tree type = TREE_TYPE (field);
2732   tree w = NULL_TREE;
2733
2734   /* Detect invalid bit-field type.  */
2735   if (DECL_INITIAL (field)
2736       && ! INTEGRAL_TYPE_P (TREE_TYPE (field)))
2737     {
2738       cp_error_at ("bit-field `%#D' with non-integral type", field);
2739       w = error_mark_node;
2740     }
2741
2742   /* Detect and ignore out of range field width.  */
2743   if (DECL_INITIAL (field))
2744     {
2745       w = DECL_INITIAL (field);
2746
2747       /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs.  */
2748       STRIP_NOPS (w);
2749
2750       /* detect invalid field size.  */
2751       if (TREE_CODE (w) == CONST_DECL)
2752         w = DECL_INITIAL (w);
2753       else
2754         w = decl_constant_value (w);
2755
2756       if (TREE_CODE (w) != INTEGER_CST)
2757         {
2758           cp_error_at ("bit-field `%D' width not an integer constant",
2759                        field);
2760           w = error_mark_node;
2761         }
2762       else if (tree_int_cst_sgn (w) < 0)
2763         {
2764           cp_error_at ("negative width in bit-field `%D'", field);
2765           w = error_mark_node;
2766         }
2767       else if (integer_zerop (w) && DECL_NAME (field) != 0)
2768         {
2769           cp_error_at ("zero width for bit-field `%D'", field);
2770           w = error_mark_node;
2771         }
2772       else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2773                && TREE_CODE (type) != ENUMERAL_TYPE
2774                && TREE_CODE (type) != BOOLEAN_TYPE)
2775         cp_warning_at ("width of `%D' exceeds its type", field);
2776       else if (TREE_CODE (type) == ENUMERAL_TYPE
2777                && (0 > compare_tree_int (w,
2778                                          min_precision (TYPE_MIN_VALUE (type),
2779                                                         TREE_UNSIGNED (type)))
2780                    ||  0 > compare_tree_int (w,
2781                                              min_precision
2782                                              (TYPE_MAX_VALUE (type),
2783                                               TREE_UNSIGNED (type)))))
2784         cp_warning_at ("`%D' is too small to hold all values of `%#T'",
2785                        field, type);
2786     }
2787
2788   /* Remove the bit-field width indicator so that the rest of the
2789      compiler does not treat that value as an initializer.  */
2790   DECL_INITIAL (field) = NULL_TREE;
2791
2792   if (w != error_mark_node)
2793     {
2794       DECL_SIZE (field) = convert (bitsizetype, w);
2795       DECL_BIT_FIELD (field) = 1;
2796     }
2797   else
2798     {
2799       /* Non-bit-fields are aligned for their type.  */
2800       DECL_BIT_FIELD (field) = 0;
2801       CLEAR_DECL_C_BIT_FIELD (field);
2802     }
2803 }
2804
2805 /* FIELD is a non bit-field.  We are finishing the processing for its
2806    enclosing type T.  Issue any appropriate messages and set appropriate
2807    flags.  */
2808
2809 static void
2810 check_field_decl (tree field,
2811                   tree t,
2812                   int* cant_have_const_ctor,
2813                   int* cant_have_default_ctor,
2814                   int* no_const_asn_ref,
2815                   int* any_default_members)
2816 {
2817   tree type = strip_array_types (TREE_TYPE (field));
2818
2819   /* An anonymous union cannot contain any fields which would change
2820      the settings of CANT_HAVE_CONST_CTOR and friends.  */
2821   if (ANON_UNION_TYPE_P (type))
2822     ;
2823   /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2824      structs.  So, we recurse through their fields here.  */
2825   else if (ANON_AGGR_TYPE_P (type))
2826     {
2827       tree fields;
2828
2829       for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2830         if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2831           check_field_decl (fields, t, cant_have_const_ctor,
2832                             cant_have_default_ctor, no_const_asn_ref,
2833                             any_default_members);
2834     }
2835   /* Check members with class type for constructors, destructors,
2836      etc.  */
2837   else if (CLASS_TYPE_P (type))
2838     {
2839       /* Never let anything with uninheritable virtuals
2840          make it through without complaint.  */
2841       abstract_virtuals_error (field, type);
2842
2843       if (TREE_CODE (t) == UNION_TYPE)
2844         {
2845           if (TYPE_NEEDS_CONSTRUCTING (type))
2846             cp_error_at ("member `%#D' with constructor not allowed in union",
2847                          field);
2848           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2849             cp_error_at ("member `%#D' with destructor not allowed in union",
2850                          field);
2851           if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2852             cp_error_at ("member `%#D' with copy assignment operator not allowed in union",
2853                          field);
2854         }
2855       else
2856         {
2857           TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2858           TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2859             |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2860           TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
2861           TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
2862         }
2863
2864       if (!TYPE_HAS_CONST_INIT_REF (type))
2865         *cant_have_const_ctor = 1;
2866
2867       if (!TYPE_HAS_CONST_ASSIGN_REF (type))
2868         *no_const_asn_ref = 1;
2869
2870       if (TYPE_HAS_CONSTRUCTOR (type)
2871           && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2872         *cant_have_default_ctor = 1;
2873     }
2874   if (DECL_INITIAL (field) != NULL_TREE)
2875     {
2876       /* `build_class_init_list' does not recognize
2877          non-FIELD_DECLs.  */
2878       if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
2879         error ("multiple fields in union `%T' initialized", t);
2880       *any_default_members = 1;
2881     }
2882 }
2883
2884 /* Check the data members (both static and non-static), class-scoped
2885    typedefs, etc., appearing in the declaration of T.  Issue
2886    appropriate diagnostics.  Sets ACCESS_DECLS to a list (in
2887    declaration order) of access declarations; each TREE_VALUE in this
2888    list is a USING_DECL.
2889
2890    In addition, set the following flags:
2891
2892      EMPTY_P
2893        The class is empty, i.e., contains no non-static data members.
2894
2895      CANT_HAVE_DEFAULT_CTOR_P
2896        This class cannot have an implicitly generated default
2897        constructor.
2898
2899      CANT_HAVE_CONST_CTOR_P
2900        This class cannot have an implicitly generated copy constructor
2901        taking a const reference.
2902
2903      CANT_HAVE_CONST_ASN_REF
2904        This class cannot have an implicitly generated assignment
2905        operator taking a const reference.
2906
2907    All of these flags should be initialized before calling this
2908    function.
2909
2910    Returns a pointer to the end of the TYPE_FIELDs chain; additional
2911    fields can be added by adding to this chain.  */
2912
2913 static void
2914 check_field_decls (tree t, tree *access_decls,
2915                    int *cant_have_default_ctor_p,
2916                    int *cant_have_const_ctor_p,
2917                    int *no_const_asn_ref_p)
2918 {
2919   tree *field;
2920   tree *next;
2921   int has_pointers;
2922   int any_default_members;
2923
2924   /* Assume there are no access declarations.  */
2925   *access_decls = NULL_TREE;
2926   /* Assume this class has no pointer members.  */
2927   has_pointers = 0;
2928   /* Assume none of the members of this class have default
2929      initializations.  */
2930   any_default_members = 0;
2931
2932   for (field = &TYPE_FIELDS (t); *field; field = next)
2933     {
2934       tree x = *field;
2935       tree type = TREE_TYPE (x);
2936
2937       next = &TREE_CHAIN (x);
2938
2939       if (TREE_CODE (x) == FIELD_DECL)
2940         {
2941           if (TYPE_PACKED (t))
2942             {
2943               if (!pod_type_p (TREE_TYPE (x)) && !TYPE_PACKED (TREE_TYPE (x)))
2944                 cp_warning_at
2945                   ("ignoring packed attribute on unpacked non-POD field `%#D'",
2946                    x);
2947               else
2948                 DECL_PACKED (x) = 1;
2949             }
2950
2951           if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
2952             /* We don't treat zero-width bitfields as making a class
2953                non-empty.  */
2954             ;
2955           else
2956             {
2957               tree element_type;
2958
2959               /* The class is non-empty.  */
2960               CLASSTYPE_EMPTY_P (t) = 0;
2961               /* The class is not even nearly empty.  */
2962               CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
2963               /* If one of the data members contains an empty class,
2964                  so does T.  */
2965               element_type = strip_array_types (type);
2966               if (CLASS_TYPE_P (element_type)
2967                   && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
2968                 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
2969             }
2970         }
2971
2972       if (TREE_CODE (x) == USING_DECL)
2973         {
2974           /* Prune the access declaration from the list of fields.  */
2975           *field = TREE_CHAIN (x);
2976
2977           /* Save the access declarations for our caller.  */
2978           *access_decls = tree_cons (NULL_TREE, x, *access_decls);
2979
2980           /* Since we've reset *FIELD there's no reason to skip to the
2981              next field.  */
2982           next = field;
2983           continue;
2984         }
2985
2986       if (TREE_CODE (x) == TYPE_DECL
2987           || TREE_CODE (x) == TEMPLATE_DECL)
2988         continue;
2989
2990       /* If we've gotten this far, it's a data member, possibly static,
2991          or an enumerator.  */
2992       DECL_CONTEXT (x) = t;
2993
2994       /* When this goes into scope, it will be a non-local reference.  */
2995       DECL_NONLOCAL (x) = 1;
2996
2997       if (TREE_CODE (t) == UNION_TYPE)
2998         {
2999           /* [class.union]
3000
3001              If a union contains a static data member, or a member of
3002              reference type, the program is ill-formed. */
3003           if (TREE_CODE (x) == VAR_DECL)
3004             {
3005               cp_error_at ("`%D' may not be static because it is a member of a union", x);
3006               continue;
3007             }
3008           if (TREE_CODE (type) == REFERENCE_TYPE)
3009             {
3010               cp_error_at ("`%D' may not have reference type `%T' because it is a member of a union",
3011                            x, type);
3012               continue;
3013             }
3014         }
3015
3016       /* ``A local class cannot have static data members.'' ARM 9.4 */
3017       if (current_function_decl && TREE_STATIC (x))
3018         cp_error_at ("field `%D' in local class cannot be static", x);
3019
3020       /* Perform error checking that did not get done in
3021          grokdeclarator.  */
3022       if (TREE_CODE (type) == FUNCTION_TYPE)
3023         {
3024           cp_error_at ("field `%D' invalidly declared function type",
3025                        x);
3026           type = build_pointer_type (type);
3027           TREE_TYPE (x) = type;
3028         }
3029       else if (TREE_CODE (type) == METHOD_TYPE)
3030         {
3031           cp_error_at ("field `%D' invalidly declared method type", x);
3032           type = build_pointer_type (type);
3033           TREE_TYPE (x) = type;
3034         }
3035
3036       if (type == error_mark_node)
3037         continue;
3038
3039       if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
3040         continue;
3041
3042       /* Now it can only be a FIELD_DECL.  */
3043
3044       if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3045         CLASSTYPE_NON_AGGREGATE (t) = 1;
3046
3047       /* If this is of reference type, check if it needs an init.
3048          Also do a little ANSI jig if necessary.  */
3049       if (TREE_CODE (type) == REFERENCE_TYPE)
3050         {
3051           CLASSTYPE_NON_POD_P (t) = 1;
3052           if (DECL_INITIAL (x) == NULL_TREE)
3053             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3054
3055           /* ARM $12.6.2: [A member initializer list] (or, for an
3056              aggregate, initialization by a brace-enclosed list) is the
3057              only way to initialize nonstatic const and reference
3058              members.  */
3059           *cant_have_default_ctor_p = 1;
3060           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3061
3062           if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
3063               && extra_warnings)
3064             cp_warning_at ("non-static reference `%#D' in class without a constructor", x);
3065         }
3066
3067       type = strip_array_types (type);
3068
3069       if (TYPE_PTR_P (type))
3070         has_pointers = 1;
3071
3072       if (CLASS_TYPE_P (type))
3073         {
3074           if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3075             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3076           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3077             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3078         }
3079
3080       if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3081         CLASSTYPE_HAS_MUTABLE (t) = 1;
3082
3083       if (! pod_type_p (type))
3084         /* DR 148 now allows pointers to members (which are POD themselves),
3085            to be allowed in POD structs.  */
3086         CLASSTYPE_NON_POD_P (t) = 1;
3087
3088       if (! zero_init_p (type))
3089         CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3090
3091       /* If any field is const, the structure type is pseudo-const.  */
3092       if (CP_TYPE_CONST_P (type))
3093         {
3094           C_TYPE_FIELDS_READONLY (t) = 1;
3095           if (DECL_INITIAL (x) == NULL_TREE)
3096             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3097
3098           /* ARM $12.6.2: [A member initializer list] (or, for an
3099              aggregate, initialization by a brace-enclosed list) is the
3100              only way to initialize nonstatic const and reference
3101              members.  */
3102           *cant_have_default_ctor_p = 1;
3103           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3104
3105           if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
3106               && extra_warnings)
3107             cp_warning_at ("non-static const member `%#D' in class without a constructor", x);
3108         }
3109       /* A field that is pseudo-const makes the structure likewise.  */
3110       else if (CLASS_TYPE_P (type))
3111         {
3112           C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3113           SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3114             CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3115             | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3116         }
3117
3118       /* Core issue 80: A nonstatic data member is required to have a
3119          different name from the class iff the class has a
3120          user-defined constructor.  */
3121       if (constructor_name_p (DECL_NAME (x), t) && TYPE_HAS_CONSTRUCTOR (t))
3122         cp_pedwarn_at ("field `%#D' with same name as class", x);
3123
3124       /* We set DECL_C_BIT_FIELD in grokbitfield.
3125          If the type and width are valid, we'll also set DECL_BIT_FIELD.  */
3126       if (DECL_C_BIT_FIELD (x))
3127         check_bitfield_decl (x);
3128       else
3129         check_field_decl (x, t,
3130                           cant_have_const_ctor_p,
3131                           cant_have_default_ctor_p,
3132                           no_const_asn_ref_p,
3133                           &any_default_members);
3134     }
3135
3136   /* Effective C++ rule 11.  */
3137   if (has_pointers && warn_ecpp && TYPE_HAS_CONSTRUCTOR (t)
3138       && ! (TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3139     {
3140       warning ("`%#T' has pointer data members", t);
3141
3142       if (! TYPE_HAS_INIT_REF (t))
3143         {
3144           warning ("  but does not override `%T(const %T&)'", t, t);
3145           if (! TYPE_HAS_ASSIGN_REF (t))
3146             warning ("  or `operator=(const %T&)'", t);
3147         }
3148       else if (! TYPE_HAS_ASSIGN_REF (t))
3149         warning ("  but does not override `operator=(const %T&)'", t);
3150     }
3151
3152
3153   /* Check anonymous struct/anonymous union fields.  */
3154   finish_struct_anon (t);
3155
3156   /* We've built up the list of access declarations in reverse order.
3157      Fix that now.  */
3158   *access_decls = nreverse (*access_decls);
3159 }
3160
3161 /* If TYPE is an empty class type, records its OFFSET in the table of
3162    OFFSETS.  */
3163
3164 static int
3165 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3166 {
3167   splay_tree_node n;
3168
3169   if (!is_empty_class (type))
3170     return 0;
3171
3172   /* Record the location of this empty object in OFFSETS.  */
3173   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3174   if (!n)
3175     n = splay_tree_insert (offsets,
3176                            (splay_tree_key) offset,
3177                            (splay_tree_value) NULL_TREE);
3178   n->value = ((splay_tree_value)
3179               tree_cons (NULL_TREE,
3180                          type,
3181                          (tree) n->value));
3182
3183   return 0;
3184 }
3185
3186 /* Returns nonzero if TYPE is an empty class type and there is
3187    already an entry in OFFSETS for the same TYPE as the same OFFSET.  */
3188
3189 static int
3190 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3191 {
3192   splay_tree_node n;
3193   tree t;
3194
3195   if (!is_empty_class (type))
3196     return 0;
3197
3198   /* Record the location of this empty object in OFFSETS.  */
3199   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3200   if (!n)
3201     return 0;
3202
3203   for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3204     if (same_type_p (TREE_VALUE (t), type))
3205       return 1;
3206
3207   return 0;
3208 }
3209
3210 /* Walk through all the subobjects of TYPE (located at OFFSET).  Call
3211    F for every subobject, passing it the type, offset, and table of
3212    OFFSETS.  If VBASES_P is one, then virtual non-primary bases should
3213    be traversed.
3214
3215    If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3216    than MAX_OFFSET will not be walked.
3217
3218    If F returns a nonzero value, the traversal ceases, and that value
3219    is returned.  Otherwise, returns zero.  */
3220
3221 static int
3222 walk_subobject_offsets (tree type,
3223                         subobject_offset_fn f,
3224                         tree offset,
3225                         splay_tree offsets,
3226                         tree max_offset,
3227                         int vbases_p)
3228 {
3229   int r = 0;
3230   tree type_binfo = NULL_TREE;
3231
3232   /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3233      stop.  */
3234   if (max_offset && INT_CST_LT (max_offset, offset))
3235     return 0;
3236
3237   if (!TYPE_P (type))
3238     {
3239       if (abi_version_at_least (2))
3240         type_binfo = type;
3241       type = BINFO_TYPE (type);
3242     }
3243
3244   if (CLASS_TYPE_P (type))
3245     {
3246       tree field;
3247       tree binfo;
3248       int i;
3249
3250       /* Avoid recursing into objects that are not interesting.  */
3251       if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3252         return 0;
3253
3254       /* Record the location of TYPE.  */
3255       r = (*f) (type, offset, offsets);
3256       if (r)
3257         return r;
3258
3259       /* Iterate through the direct base classes of TYPE.  */
3260       if (!type_binfo)
3261         type_binfo = TYPE_BINFO (type);
3262       for (i = 0; i < BINFO_N_BASETYPES (type_binfo); ++i)
3263         {
3264           tree binfo_offset;
3265
3266           binfo = BINFO_BASETYPE (type_binfo, i);
3267
3268           if (abi_version_at_least (2)
3269               && TREE_VIA_VIRTUAL (binfo))
3270             continue;
3271
3272           if (!vbases_p
3273               && TREE_VIA_VIRTUAL (binfo)
3274               && !BINFO_PRIMARY_P (binfo))
3275             continue;
3276
3277           if (!abi_version_at_least (2))
3278             binfo_offset = size_binop (PLUS_EXPR,
3279                                        offset,
3280                                        BINFO_OFFSET (binfo));
3281           else
3282             {
3283               tree orig_binfo;
3284               /* We cannot rely on BINFO_OFFSET being set for the base
3285                  class yet, but the offsets for direct non-virtual
3286                  bases can be calculated by going back to the TYPE.  */
3287               orig_binfo = BINFO_BASETYPE (TYPE_BINFO (type), i);
3288               binfo_offset = size_binop (PLUS_EXPR,
3289                                          offset,
3290                                          BINFO_OFFSET (orig_binfo));
3291             }
3292
3293           r = walk_subobject_offsets (binfo,
3294                                       f,
3295                                       binfo_offset,
3296                                       offsets,
3297                                       max_offset,
3298                                       (abi_version_at_least (2)
3299                                        ? /*vbases_p=*/0 : vbases_p));
3300           if (r)
3301             return r;
3302         }
3303
3304       if (abi_version_at_least (2))
3305         {
3306           tree vbase;
3307
3308           /* Iterate through the virtual base classes of TYPE.  In G++
3309              3.2, we included virtual bases in the direct base class
3310              loop above, which results in incorrect results; the
3311              correct offsets for virtual bases are only known when
3312              working with the most derived type.  */
3313           if (vbases_p)
3314             for (vbase = CLASSTYPE_VBASECLASSES (type);
3315                  vbase;
3316                  vbase = TREE_CHAIN (vbase))
3317               {
3318                 binfo = TREE_VALUE (vbase);
3319                 r = walk_subobject_offsets (binfo,
3320                                             f,
3321                                             size_binop (PLUS_EXPR,
3322                                                         offset,
3323                                                         BINFO_OFFSET (binfo)),
3324                                             offsets,
3325                                             max_offset,
3326                                             /*vbases_p=*/0);
3327                 if (r)
3328                   return r;
3329               }
3330           else
3331             {
3332               /* We still have to walk the primary base, if it is
3333                  virtual.  (If it is non-virtual, then it was walked
3334                  above.)  */
3335               vbase = get_primary_binfo (type_binfo);
3336               if (vbase && TREE_VIA_VIRTUAL (vbase)
3337                   && BINFO_PRIMARY_BASE_OF (vbase) == type_binfo)
3338                 {
3339                   r = (walk_subobject_offsets
3340                        (vbase, f, offset,
3341                         offsets, max_offset, /*vbases_p=*/0));
3342                   if (r)
3343                     return r;
3344                 }
3345             }
3346         }
3347
3348       /* Iterate through the fields of TYPE.  */
3349       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3350         if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3351           {
3352             tree field_offset;
3353
3354             if (abi_version_at_least (2))
3355               field_offset = byte_position (field);
3356             else
3357               /* In G++ 3.2, DECL_FIELD_OFFSET was used.  */
3358               field_offset = DECL_FIELD_OFFSET (field);
3359
3360             r = walk_subobject_offsets (TREE_TYPE (field),
3361                                         f,
3362                                         size_binop (PLUS_EXPR,
3363                                                     offset,
3364                                                     field_offset),
3365                                         offsets,
3366                                         max_offset,
3367                                         /*vbases_p=*/1);
3368             if (r)
3369               return r;
3370           }
3371     }
3372   else if (TREE_CODE (type) == ARRAY_TYPE)
3373     {
3374       tree element_type = strip_array_types (type);
3375       tree domain = TYPE_DOMAIN (type);
3376       tree index;
3377
3378       /* Avoid recursing into objects that are not interesting.  */
3379       if (!CLASS_TYPE_P (element_type)
3380           || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3381         return 0;
3382
3383       /* Step through each of the elements in the array.  */
3384       for (index = size_zero_node;
3385            /* G++ 3.2 had an off-by-one error here.  */
3386            (abi_version_at_least (2)
3387             ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3388             : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3389            index = size_binop (PLUS_EXPR, index, size_one_node))
3390         {
3391           r = walk_subobject_offsets (TREE_TYPE (type),
3392                                       f,
3393                                       offset,
3394                                       offsets,
3395                                       max_offset,
3396                                       /*vbases_p=*/1);
3397           if (r)
3398             return r;
3399           offset = size_binop (PLUS_EXPR, offset,
3400                                TYPE_SIZE_UNIT (TREE_TYPE (type)));
3401           /* If this new OFFSET is bigger than the MAX_OFFSET, then
3402              there's no point in iterating through the remaining
3403              elements of the array.  */
3404           if (max_offset && INT_CST_LT (max_offset, offset))
3405             break;
3406         }
3407     }
3408
3409   return 0;
3410 }
3411
3412 /* Record all of the empty subobjects of TYPE (located at OFFSET) in
3413    OFFSETS.  If VBASES_P is nonzero, virtual bases of TYPE are
3414    examined.  */
3415
3416 static void
3417 record_subobject_offsets (tree type,
3418                           tree offset,
3419                           splay_tree offsets,
3420                           int vbases_p)
3421 {
3422   walk_subobject_offsets (type, record_subobject_offset, offset,
3423                           offsets, /*max_offset=*/NULL_TREE, vbases_p);
3424 }
3425
3426 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3427    OFFSET) conflict with entries in OFFSETS.  If VBASES_P is nonzero,
3428    virtual bases of TYPE are examined.  */
3429
3430 static int
3431 layout_conflict_p (tree type,
3432                    tree offset,
3433                    splay_tree offsets,
3434                    int vbases_p)
3435 {
3436   splay_tree_node max_node;
3437
3438   /* Get the node in OFFSETS that indicates the maximum offset where
3439      an empty subobject is located.  */
3440   max_node = splay_tree_max (offsets);
3441   /* If there aren't any empty subobjects, then there's no point in
3442      performing this check.  */
3443   if (!max_node)
3444     return 0;
3445
3446   return walk_subobject_offsets (type, check_subobject_offset, offset,
3447                                  offsets, (tree) (max_node->key),
3448                                  vbases_p);
3449 }
3450
3451 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3452    non-static data member of the type indicated by RLI.  BINFO is the
3453    binfo corresponding to the base subobject, OFFSETS maps offsets to
3454    types already located at those offsets.  This function determines
3455    the position of the DECL.  */
3456
3457 static void
3458 layout_nonempty_base_or_field (record_layout_info rli,
3459                                tree decl,
3460                                tree binfo,
3461                                splay_tree offsets)
3462 {
3463   tree offset = NULL_TREE;
3464   bool field_p;
3465   tree type;
3466
3467   if (binfo)
3468     {
3469       /* For the purposes of determining layout conflicts, we want to
3470          use the class type of BINFO; TREE_TYPE (DECL) will be the
3471          CLASSTYPE_AS_BASE version, which does not contain entries for
3472          zero-sized bases.  */
3473       type = TREE_TYPE (binfo);
3474       field_p = false;
3475     }
3476   else
3477     {
3478       type = TREE_TYPE (decl);
3479       field_p = true;
3480     }
3481
3482   /* Try to place the field.  It may take more than one try if we have
3483      a hard time placing the field without putting two objects of the
3484      same type at the same address.  */
3485   while (1)
3486     {
3487       struct record_layout_info_s old_rli = *rli;
3488
3489       /* Place this field.  */
3490       place_field (rli, decl);
3491       offset = byte_position (decl);
3492
3493       /* We have to check to see whether or not there is already
3494          something of the same type at the offset we're about to use.
3495          For example, consider:
3496
3497            struct S {};
3498            struct T : public S { int i; };
3499            struct U : public S, public T {};
3500
3501          Here, we put S at offset zero in U.  Then, we can't put T at
3502          offset zero -- its S component would be at the same address
3503          as the S we already allocated.  So, we have to skip ahead.
3504          Since all data members, including those whose type is an
3505          empty class, have nonzero size, any overlap can happen only
3506          with a direct or indirect base-class -- it can't happen with
3507          a data member.  */
3508       /* In a union, overlap is permitted; all members are placed at
3509          offset zero.  */
3510       if (TREE_CODE (rli->t) == UNION_TYPE)
3511         break;
3512       /* G++ 3.2 did not check for overlaps when placing a non-empty
3513          virtual base.  */
3514       if (!abi_version_at_least (2) && binfo && TREE_VIA_VIRTUAL (binfo))
3515         break;
3516       if (layout_conflict_p (field_p ? type : binfo, offset,
3517                              offsets, field_p))
3518         {
3519           /* Strip off the size allocated to this field.  That puts us
3520              at the first place we could have put the field with
3521              proper alignment.  */
3522           *rli = old_rli;
3523
3524           /* Bump up by the alignment required for the type.  */
3525           rli->bitpos
3526             = size_binop (PLUS_EXPR, rli->bitpos,
3527                           bitsize_int (binfo
3528                                        ? CLASSTYPE_ALIGN (type)
3529                                        : TYPE_ALIGN (type)));
3530           normalize_rli (rli);
3531         }
3532       else
3533         /* There was no conflict.  We're done laying out this field.  */
3534         break;
3535     }
3536
3537   /* Now that we know where it will be placed, update its
3538      BINFO_OFFSET.  */
3539   if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3540     /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3541        this point because their BINFO_OFFSET is copied from another
3542        hierarchy.  Therefore, we may not need to add the entire
3543        OFFSET.  */
3544     propagate_binfo_offsets (binfo,
3545                              size_diffop (convert (ssizetype, offset),
3546                                           convert (ssizetype,
3547                                                    BINFO_OFFSET (binfo))));
3548 }
3549
3550 /* Returns true if TYPE is empty and OFFSET is nonzero.  */
3551
3552 static int
3553 empty_base_at_nonzero_offset_p (tree type,
3554                                 tree offset,
3555                                 splay_tree offsets ATTRIBUTE_UNUSED)
3556 {
3557   return is_empty_class (type) && !integer_zerop (offset);
3558 }
3559
3560 /* Layout the empty base BINFO.  EOC indicates the byte currently just
3561    past the end of the class, and should be correctly aligned for a
3562    class of the type indicated by BINFO; OFFSETS gives the offsets of
3563    the empty bases allocated so far. T is the most derived
3564    type.  Return nonzero iff we added it at the end.  */
3565
3566 static bool
3567 layout_empty_base (tree binfo, tree eoc, splay_tree offsets)
3568 {
3569   tree alignment;
3570   tree basetype = BINFO_TYPE (binfo);
3571   bool atend = false;
3572
3573   /* This routine should only be used for empty classes.  */
3574   my_friendly_assert (is_empty_class (basetype), 20000321);
3575   alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3576
3577   if (!integer_zerop (BINFO_OFFSET (binfo)))
3578     {
3579       if (abi_version_at_least (2))
3580         propagate_binfo_offsets
3581           (binfo, size_diffop (size_zero_node, BINFO_OFFSET (binfo)));
3582       else if (warn_abi)
3583         warning ("offset of empty base `%T' may not be ABI-compliant and may"
3584                  "change in a future version of GCC",
3585                  BINFO_TYPE (binfo));
3586     }
3587
3588   /* This is an empty base class.  We first try to put it at offset
3589      zero.  */
3590   if (layout_conflict_p (binfo,
3591                          BINFO_OFFSET (binfo),
3592                          offsets,
3593                          /*vbases_p=*/0))
3594     {
3595       /* That didn't work.  Now, we move forward from the next
3596          available spot in the class.  */
3597       atend = true;
3598       propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3599       while (1)
3600         {
3601           if (!layout_conflict_p (binfo,
3602                                   BINFO_OFFSET (binfo),
3603                                   offsets,
3604                                   /*vbases_p=*/0))
3605             /* We finally found a spot where there's no overlap.  */
3606             break;
3607
3608           /* There's overlap here, too.  Bump along to the next spot.  */
3609           propagate_binfo_offsets (binfo, alignment);
3610         }
3611     }
3612   return atend;
3613 }
3614
3615 /* Layout the the base given by BINFO in the class indicated by RLI.
3616    *BASE_ALIGN is a running maximum of the alignments of
3617    any base class.  OFFSETS gives the location of empty base
3618    subobjects.  T is the most derived type.  Return nonzero if the new
3619    object cannot be nearly-empty.  A new FIELD_DECL is inserted at
3620    *NEXT_FIELD, unless BINFO is for an empty base class.
3621
3622    Returns the location at which the next field should be inserted.  */
3623
3624 static tree *
3625 build_base_field (record_layout_info rli, tree binfo,
3626                   splay_tree offsets, tree *next_field)
3627 {
3628   tree t = rli->t;
3629   tree basetype = BINFO_TYPE (binfo);
3630
3631   if (!COMPLETE_TYPE_P (basetype))
3632     /* This error is now reported in xref_tag, thus giving better
3633        location information.  */
3634     return next_field;
3635
3636   /* Place the base class.  */
3637   if (!is_empty_class (basetype))
3638     {
3639       tree decl;
3640
3641       /* The containing class is non-empty because it has a non-empty
3642          base class.  */
3643       CLASSTYPE_EMPTY_P (t) = 0;
3644
3645       /* Create the FIELD_DECL.  */
3646       decl = build_decl (FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3647       DECL_ARTIFICIAL (decl) = 1;
3648       DECL_FIELD_CONTEXT (decl) = t;
3649       DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3650       DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3651       DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3652       DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3653       DECL_IGNORED_P (decl) = 1;
3654
3655       /* Try to place the field.  It may take more than one try if we
3656          have a hard time placing the field without putting two
3657          objects of the same type at the same address.  */
3658       layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3659       /* Add the new FIELD_DECL to the list of fields for T.  */
3660       TREE_CHAIN (decl) = *next_field;
3661       *next_field = decl;
3662       next_field = &TREE_CHAIN (decl);
3663     }
3664   else
3665     {
3666       tree eoc;
3667       bool atend;
3668
3669       /* On some platforms (ARM), even empty classes will not be
3670          byte-aligned.  */
3671       eoc = round_up (rli_size_unit_so_far (rli),
3672                       CLASSTYPE_ALIGN_UNIT (basetype));
3673       atend = layout_empty_base (binfo, eoc, offsets);
3674       /* A nearly-empty class "has no proper base class that is empty,
3675          not morally virtual, and at an offset other than zero."  */
3676       if (!TREE_VIA_VIRTUAL (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3677         {
3678           if (atend)
3679             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3680           /* The check above (used in G++ 3.2) is insufficient  because
3681              an empty class placed at offset zero might itself have an
3682              empty base at a nonzero offset.  */
3683           else if (walk_subobject_offsets (basetype,
3684                                            empty_base_at_nonzero_offset_p,
3685                                            size_zero_node,
3686                                            /*offsets=*/NULL,
3687                                            /*max_offset=*/NULL_TREE,
3688                                            /*vbases_p=*/true))
3689             {
3690               if (abi_version_at_least (2))
3691                 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3692               else if (warn_abi)
3693                 warning ("class `%T' will be considered nearly empty in a "
3694                          "future version of GCC", t);
3695             }
3696         }
3697
3698       /* We do not create a FIELD_DECL for empty base classes because
3699          it might overlap some other field.  We want to be able to
3700          create CONSTRUCTORs for the class by iterating over the
3701          FIELD_DECLs, and the back end does not handle overlapping
3702          FIELD_DECLs.  */
3703
3704       /* An empty virtual base causes a class to be non-empty
3705          -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3706          here because that was already done when the virtual table
3707          pointer was created.  */
3708     }
3709
3710   /* Record the offsets of BINFO and its base subobjects.  */
3711   record_subobject_offsets (binfo,
3712                             BINFO_OFFSET (binfo),
3713                             offsets,
3714                             /*vbases_p=*/0);
3715
3716   return next_field;
3717 }
3718
3719 /* Layout all of the non-virtual base classes.  Record empty
3720    subobjects in OFFSETS.  T is the most derived type.  Return nonzero
3721    if the type cannot be nearly empty.  The fields created
3722    corresponding to the base classes will be inserted at
3723    *NEXT_FIELD.  */
3724
3725 static void
3726 build_base_fields (record_layout_info rli,
3727                    splay_tree offsets, tree *next_field)
3728 {
3729   /* Chain to hold all the new FIELD_DECLs which stand in for base class
3730      subobjects.  */
3731   tree t = rli->t;
3732   int n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
3733   int i;
3734
3735   /* The primary base class is always allocated first.  */
3736   if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3737     next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3738                                    offsets, next_field);
3739
3740   /* Now allocate the rest of the bases.  */
3741   for (i = 0; i < n_baseclasses; ++i)
3742     {
3743       tree base_binfo;
3744
3745       base_binfo = BINFO_BASETYPE (TYPE_BINFO (t), i);
3746
3747       /* The primary base was already allocated above, so we don't
3748          need to allocate it again here.  */
3749       if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3750         continue;
3751
3752       /* Virtual bases are added at the end (a primary virtual base
3753          will have already been added).  */
3754       if (TREE_VIA_VIRTUAL (base_binfo))
3755         continue;
3756
3757       next_field = build_base_field (rli, base_binfo,
3758                                      offsets, next_field);
3759     }
3760 }
3761
3762 /* Go through the TYPE_METHODS of T issuing any appropriate
3763    diagnostics, figuring out which methods override which other
3764    methods, and so forth.  */
3765
3766 static void
3767 check_methods (tree t)
3768 {
3769   tree x;
3770
3771   for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3772     {
3773       /* If this was an evil function, don't keep it in class.  */
3774       if (DECL_ASSEMBLER_NAME_SET_P (x)
3775           && IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
3776         continue;
3777
3778       check_for_override (x, t);
3779       if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3780         cp_error_at ("initializer specified for non-virtual method `%D'", x);
3781
3782       /* The name of the field is the original field name
3783          Save this in auxiliary field for later overloading.  */
3784       if (DECL_VINDEX (x))
3785         {
3786           TYPE_POLYMORPHIC_P (t) = 1;
3787           if (DECL_PURE_VIRTUAL_P (x))
3788             CLASSTYPE_PURE_VIRTUALS (t)
3789               = tree_cons (NULL_TREE, x, CLASSTYPE_PURE_VIRTUALS (t));
3790         }
3791     }
3792 }
3793
3794 /* FN is a constructor or destructor.  Clone the declaration to create
3795    a specialized in-charge or not-in-charge version, as indicated by
3796    NAME.  */
3797
3798 static tree
3799 build_clone (tree fn, tree name)
3800 {
3801   tree parms;
3802   tree clone;
3803
3804   /* Copy the function.  */
3805   clone = copy_decl (fn);
3806   /* Remember where this function came from.  */
3807   DECL_CLONED_FUNCTION (clone) = fn;
3808   DECL_ABSTRACT_ORIGIN (clone) = fn;
3809   /* Reset the function name.  */
3810   DECL_NAME (clone) = name;
3811   SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3812   /* There's no pending inline data for this function.  */
3813   DECL_PENDING_INLINE_INFO (clone) = NULL;
3814   DECL_PENDING_INLINE_P (clone) = 0;
3815   /* And it hasn't yet been deferred.  */
3816   DECL_DEFERRED_FN (clone) = 0;
3817
3818   /* The base-class destructor is not virtual.  */
3819   if (name == base_dtor_identifier)
3820     {
3821       DECL_VIRTUAL_P (clone) = 0;
3822       if (TREE_CODE (clone) != TEMPLATE_DECL)
3823         DECL_VINDEX (clone) = NULL_TREE;
3824     }
3825
3826   /* If there was an in-charge parameter, drop it from the function
3827      type.  */
3828   if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3829     {
3830       tree basetype;
3831       tree parmtypes;
3832       tree exceptions;
3833
3834       exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3835       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3836       parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
3837       /* Skip the `this' parameter.  */
3838       parmtypes = TREE_CHAIN (parmtypes);
3839       /* Skip the in-charge parameter.  */
3840       parmtypes = TREE_CHAIN (parmtypes);
3841       /* And the VTT parm, in a complete [cd]tor.  */
3842       if (DECL_HAS_VTT_PARM_P (fn)
3843           && ! DECL_NEEDS_VTT_PARM_P (clone))
3844         parmtypes = TREE_CHAIN (parmtypes);
3845        /* If this is subobject constructor or destructor, add the vtt
3846          parameter.  */
3847       TREE_TYPE (clone)
3848         = build_method_type_directly (basetype,
3849                                       TREE_TYPE (TREE_TYPE (clone)),
3850                                       parmtypes);
3851       if (exceptions)
3852         TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
3853                                                      exceptions);
3854       TREE_TYPE (clone)
3855         = cp_build_type_attribute_variant (TREE_TYPE (clone),
3856                                            TYPE_ATTRIBUTES (TREE_TYPE (fn)));
3857     }
3858
3859   /* Copy the function parameters.  But, DECL_ARGUMENTS on a TEMPLATE_DECL
3860      aren't function parameters; those are the template parameters.  */
3861   if (TREE_CODE (clone) != TEMPLATE_DECL)
3862     {
3863       DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
3864       /* Remove the in-charge parameter.  */
3865       if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3866         {
3867           TREE_CHAIN (DECL_ARGUMENTS (clone))
3868             = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3869           DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
3870         }
3871       /* And the VTT parm, in a complete [cd]tor.  */
3872       if (DECL_HAS_VTT_PARM_P (fn))
3873         {
3874           if (DECL_NEEDS_VTT_PARM_P (clone))
3875             DECL_HAS_VTT_PARM_P (clone) = 1;
3876           else
3877             {
3878               TREE_CHAIN (DECL_ARGUMENTS (clone))
3879                 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3880               DECL_HAS_VTT_PARM_P (clone) = 0;
3881             }
3882         }
3883
3884       for (parms = DECL_ARGUMENTS (clone); parms; parms = TREE_CHAIN (parms))
3885         {
3886           DECL_CONTEXT (parms) = clone;
3887           cxx_dup_lang_specific_decl (parms);
3888         }
3889     }
3890
3891   /* Create the RTL for this function.  */
3892   SET_DECL_RTL (clone, NULL_RTX);
3893   rest_of_decl_compilation (clone, NULL, /*top_level=*/1, at_eof);
3894
3895   /* Make it easy to find the CLONE given the FN.  */
3896   TREE_CHAIN (clone) = TREE_CHAIN (fn);
3897   TREE_CHAIN (fn) = clone;
3898
3899   /* If this is a template, handle the DECL_TEMPLATE_RESULT as well.  */
3900   if (TREE_CODE (clone) == TEMPLATE_DECL)
3901     {
3902       tree result;
3903
3904       DECL_TEMPLATE_RESULT (clone)
3905         = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3906       result = DECL_TEMPLATE_RESULT (clone);
3907       DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3908       DECL_TI_TEMPLATE (result) = clone;
3909     }
3910   else if (DECL_DEFERRED_FN (fn))
3911     defer_fn (clone);
3912
3913   return clone;
3914 }
3915
3916 /* Produce declarations for all appropriate clones of FN.  If
3917    UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
3918    CLASTYPE_METHOD_VEC as well.  */
3919
3920 void
3921 clone_function_decl (tree fn, int update_method_vec_p)
3922 {
3923   tree clone;
3924
3925   /* Avoid inappropriate cloning.  */
3926   if (TREE_CHAIN (fn)
3927       && DECL_CLONED_FUNCTION (TREE_CHAIN (fn)))
3928     return;
3929
3930   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
3931     {
3932       /* For each constructor, we need two variants: an in-charge version
3933          and a not-in-charge version.  */
3934       clone = build_clone (fn, complete_ctor_identifier);
3935       if (update_method_vec_p)
3936         add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3937       clone = build_clone (fn, base_ctor_identifier);
3938       if (update_method_vec_p)
3939         add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3940     }
3941   else
3942     {
3943       my_friendly_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn), 20000411);
3944
3945       /* For each destructor, we need three variants: an in-charge
3946          version, a not-in-charge version, and an in-charge deleting
3947          version.  We clone the deleting version first because that
3948          means it will go second on the TYPE_METHODS list -- and that
3949          corresponds to the correct layout order in the virtual
3950          function table.
3951
3952          For a non-virtual destructor, we do not build a deleting
3953          destructor.  */
3954       if (DECL_VIRTUAL_P (fn))
3955         {
3956           clone = build_clone (fn, deleting_dtor_identifier);
3957           if (update_method_vec_p)
3958             add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3959         }
3960       clone = build_clone (fn, complete_dtor_identifier);
3961       if (update_method_vec_p)
3962         add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3963       clone = build_clone (fn, base_dtor_identifier);
3964       if (update_method_vec_p)
3965         add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3966     }
3967
3968   /* Note that this is an abstract function that is never emitted.  */
3969   DECL_ABSTRACT (fn) = 1;
3970 }
3971
3972 /* DECL is an in charge constructor, which is being defined. This will
3973    have had an in class declaration, from whence clones were
3974    declared. An out-of-class definition can specify additional default
3975    arguments. As it is the clones that are involved in overload
3976    resolution, we must propagate the information from the DECL to its
3977    clones.  */
3978
3979 void
3980 adjust_clone_args (tree decl)
3981 {
3982   tree clone;
3983
3984   for (clone = TREE_CHAIN (decl); clone && DECL_CLONED_FUNCTION (clone);
3985        clone = TREE_CHAIN (clone))
3986     {
3987       tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone));
3988       tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
3989       tree decl_parms, clone_parms;
3990
3991       clone_parms = orig_clone_parms;
3992
3993       /* Skip the 'this' parameter.  */
3994       orig_clone_parms = TREE_CHAIN (orig_clone_parms);
3995       orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3996
3997       if (DECL_HAS_IN_CHARGE_PARM_P (decl))
3998         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3999       if (DECL_HAS_VTT_PARM_P (decl))
4000         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4001
4002       clone_parms = orig_clone_parms;
4003       if (DECL_HAS_VTT_PARM_P (clone))
4004         clone_parms = TREE_CHAIN (clone_parms);
4005
4006       for (decl_parms = orig_decl_parms; decl_parms;
4007            decl_parms = TREE_CHAIN (decl_parms),
4008              clone_parms = TREE_CHAIN (clone_parms))
4009         {
4010           my_friendly_assert (same_type_p (TREE_TYPE (decl_parms),
4011                                            TREE_TYPE (clone_parms)), 20010424);
4012
4013           if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
4014             {
4015               /* A default parameter has been added. Adjust the
4016                  clone's parameters.  */
4017               tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
4018               tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
4019               tree type;
4020
4021               clone_parms = orig_decl_parms;
4022
4023               if (DECL_HAS_VTT_PARM_P (clone))
4024                 {
4025                   clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
4026                                            TREE_VALUE (orig_clone_parms),
4027                                            clone_parms);
4028                   TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
4029                 }
4030               type = build_method_type_directly (basetype,
4031                                                  TREE_TYPE (TREE_TYPE (clone)),
4032                                                  clone_parms);
4033               if (exceptions)
4034                 type = build_exception_variant (type, exceptions);
4035               TREE_TYPE (clone) = type;
4036
4037               clone_parms = NULL_TREE;
4038               break;
4039             }
4040         }
4041       my_friendly_assert (!clone_parms, 20010424);
4042     }
4043 }
4044
4045 /* For each of the constructors and destructors in T, create an
4046    in-charge and not-in-charge variant.  */
4047
4048 static void
4049 clone_constructors_and_destructors (tree t)
4050 {
4051   tree fns;
4052
4053   /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4054      out now.  */
4055   if (!CLASSTYPE_METHOD_VEC (t))
4056     return;
4057
4058   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4059     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4060   for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4061     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4062 }
4063
4064 /* Remove all zero-width bit-fields from T.  */
4065
4066 static void
4067 remove_zero_width_bit_fields (tree t)
4068 {
4069   tree *fieldsp;
4070
4071   fieldsp = &TYPE_FIELDS (t);
4072   while (*fieldsp)
4073     {
4074       if (TREE_CODE (*fieldsp) == FIELD_DECL
4075           && DECL_C_BIT_FIELD (*fieldsp)
4076           && DECL_INITIAL (*fieldsp))
4077         *fieldsp = TREE_CHAIN (*fieldsp);
4078       else
4079         fieldsp = &TREE_CHAIN (*fieldsp);
4080     }
4081 }
4082
4083 /* Returns TRUE iff we need a cookie when dynamically allocating an
4084    array whose elements have the indicated class TYPE.  */
4085
4086 static bool
4087 type_requires_array_cookie (tree type)
4088 {
4089   tree fns;
4090   bool has_two_argument_delete_p = false;
4091
4092   my_friendly_assert (CLASS_TYPE_P (type), 20010712);
4093
4094   /* If there's a non-trivial destructor, we need a cookie.  In order
4095      to iterate through the array calling the destructor for each
4096      element, we'll have to know how many elements there are.  */
4097   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4098     return true;
4099
4100   /* If the usual deallocation function is a two-argument whose second
4101      argument is of type `size_t', then we have to pass the size of
4102      the array to the deallocation function, so we will need to store
4103      a cookie.  */
4104   fns = lookup_fnfields (TYPE_BINFO (type),
4105                          ansi_opname (VEC_DELETE_EXPR),
4106                          /*protect=*/0);
4107   /* If there are no `operator []' members, or the lookup is
4108      ambiguous, then we don't need a cookie.  */
4109   if (!fns || fns == error_mark_node)
4110     return false;
4111   /* Loop through all of the functions.  */
4112   for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4113     {
4114       tree fn;
4115       tree second_parm;
4116
4117       /* Select the current function.  */
4118       fn = OVL_CURRENT (fns);
4119       /* See if this function is a one-argument delete function.  If
4120          it is, then it will be the usual deallocation function.  */
4121       second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4122       if (second_parm == void_list_node)
4123         return false;
4124       /* Otherwise, if we have a two-argument function and the second
4125          argument is `size_t', it will be the usual deallocation
4126          function -- unless there is one-argument function, too.  */
4127       if (TREE_CHAIN (second_parm) == void_list_node
4128           && same_type_p (TREE_VALUE (second_parm), sizetype))
4129         has_two_argument_delete_p = true;
4130     }
4131
4132   return has_two_argument_delete_p;
4133 }
4134
4135 /* Check the validity of the bases and members declared in T.  Add any
4136    implicitly-generated functions (like copy-constructors and
4137    assignment operators).  Compute various flag bits (like
4138    CLASSTYPE_NON_POD_T) for T.  This routine works purely at the C++
4139    level: i.e., independently of the ABI in use.  */
4140
4141 static void
4142 check_bases_and_members (tree t)
4143 {
4144   /* Nonzero if we are not allowed to generate a default constructor
4145      for this case.  */
4146   int cant_have_default_ctor;
4147   /* Nonzero if the implicitly generated copy constructor should take
4148      a non-const reference argument.  */
4149   int cant_have_const_ctor;
4150   /* Nonzero if the the implicitly generated assignment operator
4151      should take a non-const reference argument.  */
4152   int no_const_asn_ref;
4153   tree access_decls;
4154
4155   /* By default, we use const reference arguments and generate default
4156      constructors.  */
4157   cant_have_default_ctor = 0;
4158   cant_have_const_ctor = 0;
4159   no_const_asn_ref = 0;
4160
4161   /* Check all the base-classes.  */
4162   check_bases (t, &cant_have_default_ctor, &cant_have_const_ctor,
4163                &no_const_asn_ref);
4164
4165   /* Check all the data member declarations.  */
4166   check_field_decls (t, &access_decls,
4167                      &cant_have_default_ctor,
4168                      &cant_have_const_ctor,
4169                      &no_const_asn_ref);
4170
4171   /* Check all the method declarations.  */
4172   check_methods (t);
4173
4174   /* A nearly-empty class has to be vptr-containing; a nearly empty
4175      class contains just a vptr.  */
4176   if (!TYPE_CONTAINS_VPTR_P (t))
4177     CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4178
4179   /* Do some bookkeeping that will guide the generation of implicitly
4180      declared member functions.  */
4181   TYPE_HAS_COMPLEX_INIT_REF (t)
4182     |= (TYPE_HAS_INIT_REF (t)
4183         || TYPE_USES_VIRTUAL_BASECLASSES (t)
4184         || TYPE_POLYMORPHIC_P (t));
4185   TYPE_NEEDS_CONSTRUCTING (t)
4186     |= (TYPE_HAS_CONSTRUCTOR (t)
4187         || TYPE_USES_VIRTUAL_BASECLASSES (t)
4188         || TYPE_POLYMORPHIC_P (t));
4189   CLASSTYPE_NON_AGGREGATE (t) |= (TYPE_HAS_CONSTRUCTOR (t)
4190                                   || TYPE_POLYMORPHIC_P (t));
4191   CLASSTYPE_NON_POD_P (t)
4192     |= (CLASSTYPE_NON_AGGREGATE (t) || TYPE_HAS_DESTRUCTOR (t)
4193         || TYPE_HAS_ASSIGN_REF (t));
4194   TYPE_HAS_REAL_ASSIGN_REF (t) |= TYPE_HAS_ASSIGN_REF (t);
4195   TYPE_HAS_COMPLEX_ASSIGN_REF (t)
4196     |= TYPE_HAS_ASSIGN_REF (t) || TYPE_CONTAINS_VPTR_P (t);
4197
4198   /* Synthesize any needed methods.  Note that methods will be synthesized
4199      for anonymous unions; grok_x_components undoes that.  */
4200   add_implicitly_declared_members (t, cant_have_default_ctor,
4201                                    cant_have_const_ctor,
4202                                    no_const_asn_ref);
4203
4204   /* Create the in-charge and not-in-charge variants of constructors
4205      and destructors.  */
4206   clone_constructors_and_destructors (t);
4207
4208   /* Process the using-declarations.  */
4209   for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4210     handle_using_decl (TREE_VALUE (access_decls), t);
4211
4212   /* Build and sort the CLASSTYPE_METHOD_VEC.  */
4213   finish_struct_methods (t);
4214
4215   /* Figure out whether or not we will need a cookie when dynamically
4216      allocating an array of this type.  */
4217   TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4218     = type_requires_array_cookie (t);
4219 }
4220
4221 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4222    accordingly.  If a new vfield was created (because T doesn't have a
4223    primary base class), then the newly created field is returned.  It
4224    is not added to the TYPE_FIELDS list; it is the caller's
4225    responsibility to do that.  Accumulate declared virtual functions
4226    on VIRTUALS_P.  */
4227
4228 static tree
4229 create_vtable_ptr (tree t, tree* virtuals_p)
4230 {
4231   tree fn;
4232
4233   /* Collect the virtual functions declared in T.  */
4234   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4235     if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4236         && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4237       {
4238         tree new_virtual = make_node (TREE_LIST);
4239
4240         BV_FN (new_virtual) = fn;
4241         BV_DELTA (new_virtual) = integer_zero_node;
4242
4243         TREE_CHAIN (new_virtual) = *virtuals_p;
4244         *virtuals_p = new_virtual;
4245       }
4246
4247   /* If we couldn't find an appropriate base class, create a new field
4248      here.  Even if there weren't any new virtual functions, we might need a
4249      new virtual function table if we're supposed to include vptrs in
4250      all classes that need them.  */
4251   if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4252     {
4253       /* We build this decl with vtbl_ptr_type_node, which is a
4254          `vtable_entry_type*'.  It might seem more precise to use
4255          `vtable_entry_type (*)[N]' where N is the number of firtual
4256          functions.  However, that would require the vtable pointer in
4257          base classes to have a different type than the vtable pointer
4258          in derived classes.  We could make that happen, but that
4259          still wouldn't solve all the problems.  In particular, the
4260          type-based alias analysis code would decide that assignments
4261          to the base class vtable pointer can't alias assignments to
4262          the derived class vtable pointer, since they have different
4263          types.  Thus, in a derived class destructor, where the base
4264          class constructor was inlined, we could generate bad code for
4265          setting up the vtable pointer.
4266
4267          Therefore, we use one type for all vtable pointers.  We still
4268          use a type-correct type; it's just doesn't indicate the array
4269          bounds.  That's better than using `void*' or some such; it's
4270          cleaner, and it let's the alias analysis code know that these
4271          stores cannot alias stores to void*!  */
4272       tree field;
4273
4274       field = build_decl (FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4275       SET_DECL_ASSEMBLER_NAME (field, get_identifier (VFIELD_BASE));
4276       DECL_VIRTUAL_P (field) = 1;
4277       DECL_ARTIFICIAL (field) = 1;
4278       DECL_FIELD_CONTEXT (field) = t;
4279       DECL_FCONTEXT (field) = t;
4280
4281       TYPE_VFIELD (t) = field;
4282
4283       /* This class is non-empty.  */
4284       CLASSTYPE_EMPTY_P (t) = 0;
4285
4286       if (CLASSTYPE_N_BASECLASSES (t))
4287         /* If there were any baseclasses, they can't possibly be at
4288            offset zero any more, because that's where the vtable
4289            pointer is.  So, converting to a base class is going to
4290            take work.  */
4291         TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t) = 1;
4292
4293       return field;
4294     }
4295
4296   return NULL_TREE;
4297 }
4298
4299 /* Fixup the inline function given by INFO now that the class is
4300    complete.  */
4301
4302 static void
4303 fixup_pending_inline (tree fn)
4304 {
4305   if (DECL_PENDING_INLINE_INFO (fn))
4306     {
4307       tree args = DECL_ARGUMENTS (fn);
4308       while (args)
4309         {
4310           DECL_CONTEXT (args) = fn;
4311           args = TREE_CHAIN (args);
4312         }
4313     }
4314 }
4315
4316 /* Fixup the inline methods and friends in TYPE now that TYPE is
4317    complete.  */
4318
4319 static void
4320 fixup_inline_methods (tree type)
4321 {
4322   tree method = TYPE_METHODS (type);
4323
4324   if (method && TREE_CODE (method) == TREE_VEC)
4325     {
4326       if (TREE_VEC_ELT (method, 1))
4327         method = TREE_VEC_ELT (method, 1);
4328       else if (TREE_VEC_ELT (method, 0))
4329         method = TREE_VEC_ELT (method, 0);
4330       else
4331         method = TREE_VEC_ELT (method, 2);
4332     }
4333
4334   /* Do inline member functions.  */
4335   for (; method; method = TREE_CHAIN (method))
4336     fixup_pending_inline (method);
4337
4338   /* Do friends.  */
4339   for (method = CLASSTYPE_INLINE_FRIENDS (type);
4340        method;
4341        method = TREE_CHAIN (method))
4342     fixup_pending_inline (TREE_VALUE (method));
4343   CLASSTYPE_INLINE_FRIENDS (type) = NULL_TREE;
4344 }
4345
4346 /* Add OFFSET to all base types of BINFO which is a base in the
4347    hierarchy dominated by T.
4348
4349    OFFSET, which is a type offset, is number of bytes.  */
4350
4351 static void
4352 propagate_binfo_offsets (tree binfo, tree offset)
4353 {
4354   int i;
4355   tree primary_binfo;
4356
4357   /* Update BINFO's offset.  */
4358   BINFO_OFFSET (binfo)
4359     = convert (sizetype,
4360                size_binop (PLUS_EXPR,
4361                            convert (ssizetype, BINFO_OFFSET (binfo)),
4362                            offset));
4363
4364   /* Find the primary base class.  */
4365   primary_binfo = get_primary_binfo (binfo);
4366
4367   /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4368      downwards.  */
4369   for (i = -1; i < BINFO_N_BASETYPES (binfo); ++i)
4370     {
4371       tree base_binfo;
4372
4373       /* On the first time through the loop, do the primary base.
4374          Because the primary base need not be an immediate base, we
4375          must handle the primary base specially.  */
4376       if (i == -1)
4377         {
4378           if (!primary_binfo)
4379             continue;
4380
4381           base_binfo = primary_binfo;
4382         }
4383       else
4384         {
4385           base_binfo = BINFO_BASETYPE (binfo, i);
4386           /* Don't do the primary base twice.  */
4387           if (base_binfo == primary_binfo)
4388             continue;
4389         }
4390
4391       /* Skip virtual bases that aren't our canonical primary base.  */
4392       if (TREE_VIA_VIRTUAL (base_binfo)
4393           && BINFO_PRIMARY_BASE_OF (base_binfo) != binfo)
4394         continue;
4395
4396       propagate_binfo_offsets (base_binfo, offset);
4397     }
4398 }
4399
4400 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T.  Update
4401    TYPE_ALIGN and TYPE_SIZE for T.  OFFSETS gives the location of
4402    empty subobjects of T.  */
4403
4404 static void
4405 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4406 {
4407   tree vbase;
4408   tree t = rli->t;
4409   bool first_vbase = true;
4410   tree *next_field;
4411
4412   if (CLASSTYPE_N_BASECLASSES (t) == 0)
4413     return;
4414
4415   if (!abi_version_at_least(2))
4416     {
4417       /* In G++ 3.2, we incorrectly rounded the size before laying out
4418          the virtual bases.  */
4419       finish_record_layout (rli, /*free_p=*/false);
4420 #ifdef STRUCTURE_SIZE_BOUNDARY
4421       /* Packed structures don't need to have minimum size.  */
4422       if (! TYPE_PACKED (t))
4423         TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
4424 #endif
4425       rli->offset = TYPE_SIZE_UNIT (t);
4426       rli->bitpos = bitsize_zero_node;
4427       rli->record_align = TYPE_ALIGN (t);
4428     }
4429
4430   /* Find the last field.  The artificial fields created for virtual
4431      bases will go after the last extant field to date.  */
4432   next_field = &TYPE_FIELDS (t);
4433   while (*next_field)
4434     next_field = &TREE_CHAIN (*next_field);
4435
4436   /* Go through the virtual bases, allocating space for each virtual
4437      base that is not already a primary base class.  These are
4438      allocated in inheritance graph order.  */
4439   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
4440     {
4441       if (!TREE_VIA_VIRTUAL (vbase))
4442         continue;
4443
4444       if (!BINFO_PRIMARY_P (vbase))
4445         {
4446           tree basetype = TREE_TYPE (vbase);
4447
4448           /* This virtual base is not a primary base of any class in the
4449              hierarchy, so we have to add space for it.  */
4450           next_field = build_base_field (rli, vbase,
4451                                          offsets, next_field);
4452
4453           /* If the first virtual base might have been placed at a
4454              lower address, had we started from CLASSTYPE_SIZE, rather
4455              than TYPE_SIZE, issue a warning.  There can be both false
4456              positives and false negatives from this warning in rare
4457              cases; to deal with all the possibilities would probably
4458              require performing both layout algorithms and comparing
4459              the results which is not particularly tractable.  */
4460           if (warn_abi
4461               && first_vbase
4462               && (tree_int_cst_lt
4463                   (size_binop (CEIL_DIV_EXPR,
4464                                round_up (CLASSTYPE_SIZE (t),
4465                                          CLASSTYPE_ALIGN (basetype)),
4466                                bitsize_unit_node),
4467                    BINFO_OFFSET (vbase))))
4468             warning ("offset of virtual base `%T' is not ABI-compliant and may change in a future version of GCC",
4469                      basetype);
4470
4471           first_vbase = false;
4472         }
4473     }
4474 }
4475
4476 /* Returns the offset of the byte just past the end of the base class
4477    BINFO.  */
4478
4479 static tree
4480 end_of_base (tree binfo)
4481 {
4482   tree size;
4483
4484   if (is_empty_class (BINFO_TYPE (binfo)))
4485     /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4486        allocate some space for it. It cannot have virtual bases, so
4487        TYPE_SIZE_UNIT is fine.  */
4488     size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4489   else
4490     size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4491
4492   return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
4493 }
4494
4495 /* Returns the offset of the byte just past the end of the base class
4496    with the highest offset in T.  If INCLUDE_VIRTUALS_P is zero, then
4497    only non-virtual bases are included.  */
4498
4499 static tree
4500 end_of_class (tree t, int include_virtuals_p)
4501 {
4502   tree result = size_zero_node;
4503   tree binfo;
4504   tree offset;
4505   int i;
4506
4507   for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i)
4508     {
4509       binfo = BINFO_BASETYPE (TYPE_BINFO (t), i);
4510
4511       if (!include_virtuals_p
4512           && TREE_VIA_VIRTUAL (binfo)
4513           && BINFO_PRIMARY_BASE_OF (binfo) != TYPE_BINFO (t))
4514         continue;
4515
4516       offset = end_of_base (binfo);
4517       if (INT_CST_LT_UNSIGNED (result, offset))
4518         result = offset;
4519     }
4520
4521   /* G++ 3.2 did not check indirect virtual bases.  */
4522   if (abi_version_at_least (2) && include_virtuals_p)
4523     for (binfo = CLASSTYPE_VBASECLASSES (t);
4524          binfo;
4525          binfo = TREE_CHAIN (binfo))
4526       {
4527         offset = end_of_base (TREE_VALUE (binfo));
4528         if (INT_CST_LT_UNSIGNED (result, offset))
4529           result = offset;
4530       }
4531
4532   return result;
4533 }
4534
4535 /* Warn about bases of T that are inaccessible because they are
4536    ambiguous.  For example:
4537
4538      struct S {};
4539      struct T : public S {};
4540      struct U : public S, public T {};
4541
4542    Here, `(S*) new U' is not allowed because there are two `S'
4543    subobjects of U.  */
4544
4545 static void
4546 warn_about_ambiguous_bases (tree t)
4547 {
4548   int i;
4549   tree vbases;
4550   tree basetype;
4551
4552   /* Check direct bases.  */
4553   for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i)
4554     {
4555       basetype = TYPE_BINFO_BASETYPE (t, i);
4556
4557       if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL))
4558         warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
4559                  basetype, t);
4560     }
4561
4562   /* Check for ambiguous virtual bases.  */
4563   if (extra_warnings)
4564     for (vbases = CLASSTYPE_VBASECLASSES (t);
4565          vbases;
4566          vbases = TREE_CHAIN (vbases))
4567       {
4568         basetype = BINFO_TYPE (TREE_VALUE (vbases));
4569
4570         if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL))
4571           warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
4572                    basetype, t);
4573       }
4574 }
4575
4576 /* Compare two INTEGER_CSTs K1 and K2.  */
4577
4578 static int
4579 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
4580 {
4581   return tree_int_cst_compare ((tree) k1, (tree) k2);
4582 }
4583
4584 /* Increase the size indicated in RLI to account for empty classes
4585    that are "off the end" of the class.  */
4586
4587 static void
4588 include_empty_classes (record_layout_info rli)
4589 {
4590   tree eoc;
4591   tree rli_size;
4592
4593   /* It might be the case that we grew the class to allocate a
4594      zero-sized base class.  That won't be reflected in RLI, yet,
4595      because we are willing to overlay multiple bases at the same
4596      offset.  However, now we need to make sure that RLI is big enough
4597      to reflect the entire class.  */
4598   eoc = end_of_class (rli->t,
4599                       CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
4600   rli_size = rli_size_unit_so_far (rli);
4601   if (TREE_CODE (rli_size) == INTEGER_CST
4602       && INT_CST_LT_UNSIGNED (rli_size, eoc))
4603     {
4604       if (!abi_version_at_least (2))
4605         /* In version 1 of the ABI, the size of a class that ends with
4606            a bitfield was not rounded up to a whole multiple of a
4607            byte.  Because rli_size_unit_so_far returns only the number
4608            of fully allocated bytes, any extra bits were not included
4609            in the size.  */
4610         rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
4611       else
4612         /* The size should have been rounded to a whole byte.  */
4613         my_friendly_assert (tree_int_cst_equal (rli->bitpos,
4614                                                 round_down (rli->bitpos,
4615                                                             BITS_PER_UNIT)),
4616                             20030903);
4617       rli->bitpos
4618         = size_binop (PLUS_EXPR,
4619                       rli->bitpos,
4620                       size_binop (MULT_EXPR,
4621                                   convert (bitsizetype,
4622                                            size_binop (MINUS_EXPR,
4623                                                        eoc, rli_size)),
4624                                   bitsize_int (BITS_PER_UNIT)));
4625       normalize_rli (rli);
4626     }
4627 }
4628
4629 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T.  Calculate
4630    BINFO_OFFSETs for all of the base-classes.  Position the vtable
4631    pointer.  Accumulate declared virtual functions on VIRTUALS_P.  */
4632
4633 static void
4634 layout_class_type (tree t, tree *virtuals_p)
4635 {
4636   tree non_static_data_members;
4637   tree field;
4638   tree vptr;
4639   record_layout_info rli;
4640   /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4641      types that appear at that offset.  */
4642   splay_tree empty_base_offsets;
4643   /* True if the last field layed out was a bit-field.  */
4644   bool last_field_was_bitfield = false;
4645   /* The location at which the next field should be inserted.  */
4646   tree *next_field;
4647   /* T, as a base class.  */
4648   tree base_t;
4649
4650   /* Keep track of the first non-static data member.  */
4651   non_static_data_members = TYPE_FIELDS (t);
4652
4653   /* Start laying out the record.  */
4654   rli = start_record_layout (t);
4655
4656   /* If possible, we reuse the virtual function table pointer from one
4657      of our base classes.  */
4658   determine_primary_base (t);
4659
4660   /* Create a pointer to our virtual function table.  */
4661   vptr = create_vtable_ptr (t, virtuals_p);
4662
4663   /* The vptr is always the first thing in the class.  */
4664   if (vptr)
4665     {
4666       TREE_CHAIN (vptr) = TYPE_FIELDS (t);
4667       TYPE_FIELDS (t) = vptr;
4668       next_field = &TREE_CHAIN (vptr);
4669       place_field (rli, vptr);
4670     }
4671   else
4672     next_field = &TYPE_FIELDS (t);
4673
4674   /* Build FIELD_DECLs for all of the non-virtual base-types.  */
4675   empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
4676                                        NULL, NULL);
4677   build_base_fields (rli, empty_base_offsets, next_field);
4678
4679   /* Layout the non-static data members.  */
4680   for (field = non_static_data_members; field; field = TREE_CHAIN (field))
4681     {
4682       tree type;
4683       tree padding;
4684
4685       /* We still pass things that aren't non-static data members to
4686          the back-end, in case it wants to do something with them.  */
4687       if (TREE_CODE (field) != FIELD_DECL)
4688         {
4689           place_field (rli, field);
4690           /* If the static data member has incomplete type, keep track
4691              of it so that it can be completed later.  (The handling
4692              of pending statics in finish_record_layout is
4693              insufficient; consider:
4694
4695                struct S1;
4696                struct S2 { static S1 s1; };
4697
4698              At this point, finish_record_layout will be called, but
4699              S1 is still incomplete.)  */
4700           if (TREE_CODE (field) == VAR_DECL)
4701             maybe_register_incomplete_var (field);
4702           continue;
4703         }
4704
4705       type = TREE_TYPE (field);
4706
4707       padding = NULL_TREE;
4708
4709       /* If this field is a bit-field whose width is greater than its
4710          type, then there are some special rules for allocating
4711          it.  */
4712       if (DECL_C_BIT_FIELD (field)
4713           && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
4714         {
4715           integer_type_kind itk;
4716           tree integer_type;
4717           bool was_unnamed_p = false;
4718           /* We must allocate the bits as if suitably aligned for the
4719              longest integer type that fits in this many bits.  type
4720              of the field.  Then, we are supposed to use the left over
4721              bits as additional padding.  */
4722           for (itk = itk_char; itk != itk_none; ++itk)
4723             if (INT_CST_LT (DECL_SIZE (field),
4724                             TYPE_SIZE (integer_types[itk])))
4725               break;
4726
4727           /* ITK now indicates a type that is too large for the
4728              field.  We have to back up by one to find the largest
4729              type that fits.  */
4730           integer_type = integer_types[itk - 1];
4731
4732           /* Figure out how much additional padding is required.  GCC
4733              3.2 always created a padding field, even if it had zero
4734              width.  */
4735           if (!abi_version_at_least (2)
4736               || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
4737             {
4738               if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
4739                 /* In a union, the padding field must have the full width
4740                    of the bit-field; all fields start at offset zero.  */
4741                 padding = DECL_SIZE (field);
4742               else
4743                 {
4744                   if (warn_abi && TREE_CODE (t) == UNION_TYPE)
4745                     warning ("size assigned to `%T' may not be "
4746                              "ABI-compliant and may change in a future "
4747                              "version of GCC",
4748                              t);
4749                   padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
4750                                         TYPE_SIZE (integer_type));
4751                 }
4752             }
4753 #ifdef PCC_BITFIELD_TYPE_MATTERS
4754           /* An unnamed bitfield does not normally affect the
4755              alignment of the containing class on a target where
4756              PCC_BITFIELD_TYPE_MATTERS.  But, the C++ ABI does not
4757              make any exceptions for unnamed bitfields when the
4758              bitfields are longer than their types.  Therefore, we
4759              temporarily give the field a name.  */
4760           if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
4761             {
4762               was_unnamed_p = true;
4763               DECL_NAME (field) = make_anon_name ();
4764             }
4765 #endif
4766           DECL_SIZE (field) = TYPE_SIZE (integer_type);
4767           DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
4768           DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
4769           layout_nonempty_base_or_field (rli, field, NULL_TREE,
4770                                          empty_base_offsets);
4771           if (was_unnamed_p)
4772             DECL_NAME (field) = NULL_TREE;
4773           /* Now that layout has been performed, set the size of the
4774              field to the size of its declared type; the rest of the
4775              field is effectively invisible.  */
4776           DECL_SIZE (field) = TYPE_SIZE (type);
4777           /* We must also reset the DECL_MODE of the field.  */
4778           if (abi_version_at_least (2))
4779             DECL_MODE (field) = TYPE_MODE (type);
4780           else if (warn_abi
4781                    && DECL_MODE (field) != TYPE_MODE (type))
4782             /* Versions of G++ before G++ 3.4 did not reset the
4783                DECL_MODE.  */
4784             warning ("the offset of `%D' may not be ABI-compliant and may "
4785                      "change in a future version of GCC", field);
4786         }
4787       else
4788         layout_nonempty_base_or_field (rli, field, NULL_TREE,
4789                                        empty_base_offsets);
4790
4791       /* Remember the location of any empty classes in FIELD.  */
4792       if (abi_version_at_least (2))
4793         record_subobject_offsets (TREE_TYPE (field),
4794                                   byte_position(field),
4795                                   empty_base_offsets,
4796                                   /*vbases_p=*/1);
4797
4798       /* If a bit-field does not immediately follow another bit-field,
4799          and yet it starts in the middle of a byte, we have failed to
4800          comply with the ABI.  */
4801       if (warn_abi
4802           && DECL_C_BIT_FIELD (field)
4803           && !last_field_was_bitfield
4804           && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
4805                                          DECL_FIELD_BIT_OFFSET (field),
4806                                          bitsize_unit_node)))
4807         cp_warning_at ("offset of `%D' is not ABI-compliant and may change in a future version of GCC",
4808                        field);
4809
4810       /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4811          offset of the field.  */
4812       if (warn_abi
4813           && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
4814                                   byte_position (field))
4815           && contains_empty_class_p (TREE_TYPE (field)))
4816         cp_warning_at ("`%D' contains empty classes which may cause base "
4817                        "classes to be placed at different locations in a "
4818                        "future version of GCC",
4819                        field);
4820
4821       /* If we needed additional padding after this field, add it
4822          now.  */
4823       if (padding)
4824         {
4825           tree padding_field;
4826
4827           padding_field = build_decl (FIELD_DECL,
4828                                       NULL_TREE,
4829                                       char_type_node);
4830           DECL_BIT_FIELD (padding_field) = 1;
4831           DECL_SIZE (padding_field) = padding;
4832           DECL_CONTEXT (padding_field) = t;
4833           DECL_ARTIFICIAL (padding_field) = 1;
4834           layout_nonempty_base_or_field (rli, padding_field,
4835                                          NULL_TREE,
4836                                          empty_base_offsets);
4837         }
4838
4839       last_field_was_bitfield = DECL_C_BIT_FIELD (field);
4840     }
4841
4842   if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
4843     {
4844       /* Make sure that we are on a byte boundary so that the size of
4845          the class without virtual bases will always be a round number
4846          of bytes.  */
4847       rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT);
4848       normalize_rli (rli);
4849     }
4850
4851   /* G++ 3.2 does not allow virtual bases to be overlaid with tail
4852      padding.  */
4853   if (!abi_version_at_least (2))
4854     include_empty_classes(rli);
4855
4856   /* Delete all zero-width bit-fields from the list of fields.  Now
4857      that the type is laid out they are no longer important.  */
4858   remove_zero_width_bit_fields (t);
4859
4860   /* Create the version of T used for virtual bases.  We do not use
4861      make_aggr_type for this version; this is an artificial type.  For
4862      a POD type, we just reuse T.  */
4863   if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t))
4864     {
4865       base_t = make_node (TREE_CODE (t));
4866
4867       /* Set the size and alignment for the new type.  In G++ 3.2, all
4868          empty classes were considered to have size zero when used as
4869          base classes.  */
4870       if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
4871         {
4872           TYPE_SIZE (base_t) = bitsize_zero_node;
4873           TYPE_SIZE_UNIT (base_t) = size_zero_node;
4874           if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
4875             warning ("layout of classes derived from empty class `%T' "
4876                      "may change in a future version of GCC",
4877                      t);
4878         }
4879       else
4880         {
4881           tree eoc;
4882
4883           /* If the ABI version is not at least two, and the last
4884              field was a bit-field, RLI may not be on a byte
4885              boundary.  In particular, rli_size_unit_so_far might
4886              indicate the last complete byte, while rli_size_so_far
4887              indicates the total number of bits used.  Therefore,
4888              rli_size_so_far, rather than rli_size_unit_so_far, is
4889              used to compute TYPE_SIZE_UNIT.  */
4890           eoc = end_of_class (t, /*include_virtuals_p=*/0);
4891           TYPE_SIZE_UNIT (base_t)
4892             = size_binop (MAX_EXPR,
4893                           convert (sizetype,
4894                                    size_binop (CEIL_DIV_EXPR,
4895                                                rli_size_so_far (rli),
4896                                                bitsize_int (BITS_PER_UNIT))),
4897                           eoc);
4898           TYPE_SIZE (base_t)
4899             = size_binop (MAX_EXPR,
4900                           rli_size_so_far (rli),
4901                           size_binop (MULT_EXPR,
4902                                       convert (bitsizetype, eoc),
4903                                       bitsize_int (BITS_PER_UNIT)));
4904         }
4905       TYPE_ALIGN (base_t) = rli->record_align;
4906       TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
4907
4908       /* Copy the fields from T.  */
4909       next_field = &TYPE_FIELDS (base_t);
4910       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4911         if (TREE_CODE (field) == FIELD_DECL)
4912           {
4913             *next_field = build_decl (FIELD_DECL,
4914                                       DECL_NAME (field),
4915                                       TREE_TYPE (field));
4916             DECL_CONTEXT (*next_field) = base_t;
4917             DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
4918             DECL_FIELD_BIT_OFFSET (*next_field)
4919               = DECL_FIELD_BIT_OFFSET (field);
4920             DECL_SIZE (*next_field) = DECL_SIZE (field);
4921             DECL_MODE (*next_field) = DECL_MODE (field);
4922             next_field = &TREE_CHAIN (*next_field);
4923           }
4924
4925       /* Record the base version of the type.  */
4926       CLASSTYPE_AS_BASE (t) = base_t;
4927       TYPE_CONTEXT (base_t) = t;
4928     }
4929   else
4930     CLASSTYPE_AS_BASE (t) = t;
4931
4932   /* Every empty class contains an empty class.  */
4933   if (CLASSTYPE_EMPTY_P (t))
4934     CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
4935
4936   /* Set the TYPE_DECL for this type to contain the right
4937      value for DECL_OFFSET, so that we can use it as part
4938      of a COMPONENT_REF for multiple inheritance.  */
4939   layout_decl (TYPE_MAIN_DECL (t), 0);
4940
4941   /* Now fix up any virtual base class types that we left lying
4942      around.  We must get these done before we try to lay out the
4943      virtual function table.  As a side-effect, this will remove the
4944      base subobject fields.  */
4945   layout_virtual_bases (rli, empty_base_offsets);
4946
4947   /* Make sure that empty classes are reflected in RLI at this
4948      point.  */
4949   include_empty_classes(rli);
4950
4951   /* Make sure not to create any structures with zero size.  */
4952   if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
4953     place_field (rli,
4954                  build_decl (FIELD_DECL, NULL_TREE, char_type_node));
4955
4956   /* Let the back-end lay out the type.  */
4957   finish_record_layout (rli, /*free_p=*/true);
4958
4959   /* Warn about bases that can't be talked about due to ambiguity.  */
4960   warn_about_ambiguous_bases (t);
4961
4962   /* Clean up.  */
4963   splay_tree_delete (empty_base_offsets);
4964 }
4965
4966 /* Returns the virtual function with which the vtable for TYPE is
4967    emitted, or NULL_TREE if that heuristic is not applicable to TYPE.  */
4968
4969 static tree
4970 key_method (tree type)
4971 {
4972   tree method;
4973
4974   if (TYPE_FOR_JAVA (type)
4975       || processing_template_decl
4976       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
4977       || CLASSTYPE_INTERFACE_KNOWN (type))
4978     return NULL_TREE;
4979
4980   for (method = TYPE_METHODS (type); method != NULL_TREE;
4981        method = TREE_CHAIN (method))
4982     if (DECL_VINDEX (method) != NULL_TREE
4983         && ! DECL_DECLARED_INLINE_P (method)
4984         && ! DECL_PURE_VIRTUAL_P (method))
4985       return method;
4986
4987   return NULL_TREE;
4988 }
4989
4990 /* Perform processing required when the definition of T (a class type)
4991    is complete.  */
4992
4993 void
4994 finish_struct_1 (tree t)
4995 {
4996   tree x;
4997   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
4998   tree virtuals = NULL_TREE;
4999   int n_fields = 0;
5000   tree vfield;
5001
5002   if (COMPLETE_TYPE_P (t))
5003     {
5004       if (IS_AGGR_TYPE (t))
5005         error ("redefinition of `%#T'", t);
5006       else
5007         abort ();
5008       popclass ();
5009       return;
5010     }
5011
5012   /* If this type was previously laid out as a forward reference,
5013      make sure we lay it out again.  */
5014   TYPE_SIZE (t) = NULL_TREE;
5015   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5016
5017   fixup_inline_methods (t);
5018
5019   /* Make assumptions about the class; we'll reset the flags if
5020      necessary.  */
5021   CLASSTYPE_EMPTY_P (t) = 1;
5022   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5023   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5024
5025   /* Do end-of-class semantic processing: checking the validity of the
5026      bases and members and add implicitly generated methods.  */
5027   check_bases_and_members (t);
5028
5029   /* Find the key method.  */
5030   if (TYPE_CONTAINS_VPTR_P (t))
5031     {
5032       CLASSTYPE_KEY_METHOD (t) = key_method (t);
5033
5034       /* If a polymorphic class has no key method, we may emit the vtable
5035          in every translation unit where the class definition appears.  */
5036       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5037         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5038     }
5039
5040   /* Layout the class itself.  */
5041   layout_class_type (t, &virtuals);
5042   if (CLASSTYPE_AS_BASE (t) != t)
5043     /* We use the base type for trivial assignments, and hence it
5044        needs a mode.  */
5045     compute_record_mode (CLASSTYPE_AS_BASE (t));
5046
5047   /* Make sure that we get our own copy of the vfield FIELD_DECL.  */
5048   vfield = TYPE_VFIELD (t);
5049   if (vfield && CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5050     {
5051       tree primary = CLASSTYPE_PRIMARY_BINFO (t);
5052
5053       my_friendly_assert (same_type_p (DECL_FIELD_CONTEXT (vfield),
5054                                        BINFO_TYPE (primary)),
5055                           20010726);
5056       /* The vtable better be at the start.  */
5057       my_friendly_assert (integer_zerop (DECL_FIELD_OFFSET (vfield)),
5058                           20010726);
5059       my_friendly_assert (integer_zerop (BINFO_OFFSET (primary)),
5060                           20010726);
5061
5062       vfield = copy_decl (vfield);
5063       DECL_FIELD_CONTEXT (vfield) = t;
5064       TYPE_VFIELD (t) = vfield;
5065     }
5066   else
5067     my_friendly_assert (!vfield || DECL_FIELD_CONTEXT (vfield) == t, 20010726);
5068
5069   virtuals = modify_all_vtables (t, nreverse (virtuals));
5070
5071   /* If we created a new vtbl pointer for this class, add it to the
5072      list.  */
5073   if (TYPE_VFIELD (t) && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5074     CLASSTYPE_VFIELDS (t)
5075       = chainon (CLASSTYPE_VFIELDS (t), build_tree_list (NULL_TREE, t));
5076
5077   /* If necessary, create the primary vtable for this class.  */
5078   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5079     {
5080       /* We must enter these virtuals into the table.  */
5081       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5082         build_primary_vtable (NULL_TREE, t);
5083       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5084         /* Here we know enough to change the type of our virtual
5085            function table, but we will wait until later this function.  */
5086         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5087     }
5088
5089   if (TYPE_CONTAINS_VPTR_P (t))
5090     {
5091       int vindex;
5092       tree fn;
5093
5094       if (TYPE_BINFO_VTABLE (t))
5095         my_friendly_assert (DECL_VIRTUAL_P (TYPE_BINFO_VTABLE (t)),
5096                             20000116);
5097       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5098         my_friendly_assert (TYPE_BINFO_VIRTUALS (t) == NULL_TREE,
5099                             20000116);
5100
5101       /* Add entries for virtual functions introduced by this class.  */
5102       TYPE_BINFO_VIRTUALS (t) = chainon (TYPE_BINFO_VIRTUALS (t), virtuals);
5103
5104       /* Set DECL_VINDEX for all functions declared in this class.  */
5105       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5106            fn;
5107            fn = TREE_CHAIN (fn),
5108              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5109                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5110         {
5111           tree fndecl = BV_FN (fn);
5112
5113           if (DECL_THUNK_P (fndecl))
5114             /* A thunk. We should never be calling this entry directly
5115                from this vtable -- we'd use the entry for the non
5116                thunk base function.  */
5117             DECL_VINDEX (fndecl) = NULL_TREE;
5118           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5119             DECL_VINDEX (fndecl) = build_shared_int_cst (vindex);
5120         }
5121     }
5122
5123   finish_struct_bits (t);
5124
5125   /* Complete the rtl for any static member objects of the type we're
5126      working on.  */
5127   for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5128     if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5129         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5130       DECL_MODE (x) = TYPE_MODE (t);
5131
5132   /* Done with FIELDS...now decide whether to sort these for
5133      faster lookups later.
5134
5135      We use a small number because most searches fail (succeeding
5136      ultimately as the search bores through the inheritance
5137      hierarchy), and we want this failure to occur quickly.  */
5138
5139   n_fields = count_fields (TYPE_FIELDS (t));
5140   if (n_fields > 7)
5141     {
5142       struct sorted_fields_type *field_vec = ggc_alloc (sizeof (struct sorted_fields_type)
5143         + n_fields * sizeof (tree));
5144       field_vec->len = n_fields;
5145       add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5146       qsort (field_vec->elts, n_fields, sizeof (tree),
5147              field_decl_cmp);
5148       if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5149         retrofit_lang_decl (TYPE_MAIN_DECL (t));
5150       DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5151     }
5152
5153   if (TYPE_HAS_CONSTRUCTOR (t))
5154     {
5155       tree vfields = CLASSTYPE_VFIELDS (t);
5156
5157       for (vfields = CLASSTYPE_VFIELDS (t);
5158            vfields; vfields = TREE_CHAIN (vfields))
5159         /* Mark the fact that constructor for T could affect anybody
5160            inheriting from T who wants to initialize vtables for
5161            VFIELDS's type.  */
5162         if (VF_BINFO_VALUE (vfields))
5163           TREE_ADDRESSABLE (vfields) = 1;
5164     }
5165
5166   /* Make the rtl for any new vtables we have created, and unmark
5167      the base types we marked.  */
5168   finish_vtbls (t);
5169
5170   /* Build the VTT for T.  */
5171   build_vtt (t);
5172
5173   if (warn_nonvdtor && TYPE_POLYMORPHIC_P (t) && TYPE_HAS_DESTRUCTOR (t)
5174       && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 1)) == NULL_TREE)
5175     warning ("`%#T' has virtual functions but non-virtual destructor", t);
5176
5177   complete_vars (t);
5178
5179   if (warn_overloaded_virtual)
5180     warn_hidden (t);
5181
5182   maybe_suppress_debug_info (t);
5183
5184   dump_class_hierarchy (t);
5185
5186   /* Finish debugging output for this type.  */
5187   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5188 }
5189
5190 /* When T was built up, the member declarations were added in reverse
5191    order.  Rearrange them to declaration order.  */
5192
5193 void
5194 unreverse_member_declarations (tree t)
5195 {
5196   tree next;
5197   tree prev;
5198   tree x;
5199
5200   /* The following lists are all in reverse order.  Put them in
5201      declaration order now.  */
5202   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5203   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5204
5205   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5206      reverse order, so we can't just use nreverse.  */
5207   prev = NULL_TREE;
5208   for (x = TYPE_FIELDS (t);
5209        x && TREE_CODE (x) != TYPE_DECL;
5210        x = next)
5211     {
5212       next = TREE_CHAIN (x);
5213       TREE_CHAIN (x) = prev;
5214       prev = x;
5215     }
5216   if (prev)
5217     {
5218       TREE_CHAIN (TYPE_FIELDS (t)) = x;
5219       if (prev)
5220         TYPE_FIELDS (t) = prev;
5221     }
5222 }
5223
5224 tree
5225 finish_struct (tree t, tree attributes)
5226 {
5227   location_t saved_loc = input_location;
5228
5229   /* Now that we've got all the field declarations, reverse everything
5230      as necessary.  */
5231   unreverse_member_declarations (t);
5232
5233   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5234
5235   /* Nadger the current location so that diagnostics point to the start of
5236      the struct, not the end.  */
5237   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5238
5239   if (processing_template_decl)
5240     {
5241       finish_struct_methods (t);
5242       TYPE_SIZE (t) = bitsize_zero_node;
5243       TYPE_SIZE_UNIT (t) = size_zero_node;
5244     }
5245   else
5246     finish_struct_1 (t);
5247
5248   input_location = saved_loc;
5249
5250   TYPE_BEING_DEFINED (t) = 0;
5251
5252   if (current_class_type)
5253     popclass ();
5254   else
5255     error ("trying to finish struct, but kicked out due to previous parse errors");
5256
5257   if (processing_template_decl && at_function_scope_p ())
5258     add_stmt (build_min (TAG_DEFN, t));
5259
5260   return t;
5261 }
5262 \f
5263 /* Return the dynamic type of INSTANCE, if known.
5264    Used to determine whether the virtual function table is needed
5265    or not.
5266
5267    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5268    of our knowledge of its type.  *NONNULL should be initialized
5269    before this function is called.  */
5270
5271 static tree
5272 fixed_type_or_null (tree instance, int* nonnull, int* cdtorp)
5273 {
5274   switch (TREE_CODE (instance))
5275     {
5276     case INDIRECT_REF:
5277       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5278         return NULL_TREE;
5279       else
5280         return fixed_type_or_null (TREE_OPERAND (instance, 0),
5281                                    nonnull, cdtorp);
5282
5283     case CALL_EXPR:
5284       /* This is a call to a constructor, hence it's never zero.  */
5285       if (TREE_HAS_CONSTRUCTOR (instance))
5286         {
5287           if (nonnull)
5288             *nonnull = 1;
5289           return TREE_TYPE (instance);
5290         }
5291       return NULL_TREE;
5292
5293     case SAVE_EXPR:
5294       /* This is a call to a constructor, hence it's never zero.  */
5295       if (TREE_HAS_CONSTRUCTOR (instance))
5296         {
5297           if (nonnull)
5298             *nonnull = 1;
5299           return TREE_TYPE (instance);
5300         }
5301       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5302
5303     case RTL_EXPR:
5304       return NULL_TREE;
5305
5306     case PLUS_EXPR:
5307     case MINUS_EXPR:
5308       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5309         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5310       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5311         /* Propagate nonnull.  */
5312         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5313       return NULL_TREE;
5314
5315     case NOP_EXPR:
5316     case CONVERT_EXPR:
5317       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5318
5319     case ADDR_EXPR:
5320       if (nonnull)
5321         *nonnull = 1;
5322       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5323
5324     case COMPONENT_REF:
5325       return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull, cdtorp);
5326
5327     case VAR_DECL:
5328     case FIELD_DECL:
5329       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5330           && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
5331         {
5332           if (nonnull)
5333             *nonnull = 1;
5334           return TREE_TYPE (TREE_TYPE (instance));
5335         }
5336       /* fall through...  */
5337     case TARGET_EXPR:
5338     case PARM_DECL:
5339     case RESULT_DECL:
5340       if (IS_AGGR_TYPE (TREE_TYPE (instance)))
5341         {
5342           if (nonnull)
5343             *nonnull = 1;
5344           return TREE_TYPE (instance);
5345         }
5346       else if (instance == current_class_ptr)
5347         {
5348           if (nonnull)
5349             *nonnull = 1;
5350
5351           /* if we're in a ctor or dtor, we know our type.  */
5352           if (DECL_LANG_SPECIFIC (current_function_decl)
5353               && (DECL_CONSTRUCTOR_P (current_function_decl)
5354                   || DECL_DESTRUCTOR_P (current_function_decl)))
5355             {
5356               if (cdtorp)
5357                 *cdtorp = 1;
5358               return TREE_TYPE (TREE_TYPE (instance));
5359             }
5360         }
5361       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5362         {
5363           /* Reference variables should be references to objects.  */
5364           if (nonnull)
5365             *nonnull = 1;
5366
5367           /* DECL_VAR_MARKED_P is used to prevent recursion; a
5368              variable's initializer may refer to the variable
5369              itself.  */
5370           if (TREE_CODE (instance) == VAR_DECL
5371               && DECL_INITIAL (instance)
5372               && !DECL_VAR_MARKED_P (instance))
5373             {
5374               tree type;
5375               DECL_VAR_MARKED_P (instance) = 1;
5376               type = fixed_type_or_null (DECL_INITIAL (instance),
5377                                          nonnull, cdtorp);
5378               DECL_VAR_MARKED_P (instance) = 0;
5379               return type;
5380             }
5381         }
5382       return NULL_TREE;
5383
5384     default:
5385       return NULL_TREE;
5386     }
5387 }
5388
5389 /* Return nonzero if the dynamic type of INSTANCE is known, and
5390    equivalent to the static type.  We also handle the case where
5391    INSTANCE is really a pointer. Return negative if this is a
5392    ctor/dtor. There the dynamic type is known, but this might not be
5393    the most derived base of the original object, and hence virtual
5394    bases may not be layed out according to this type.
5395
5396    Used to determine whether the virtual function table is needed
5397    or not.
5398
5399    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5400    of our knowledge of its type.  *NONNULL should be initialized
5401    before this function is called.  */
5402
5403 int
5404 resolves_to_fixed_type_p (tree instance, int* nonnull)
5405 {
5406   tree t = TREE_TYPE (instance);
5407   int cdtorp = 0;
5408
5409   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5410   if (fixed == NULL_TREE)
5411     return 0;
5412   if (POINTER_TYPE_P (t))
5413     t = TREE_TYPE (t);
5414   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5415     return 0;
5416   return cdtorp ? -1 : 1;
5417 }
5418
5419 \f
5420 void
5421 init_class_processing (void)
5422 {
5423   current_class_depth = 0;
5424   current_class_stack_size = 10;
5425   current_class_stack
5426     = xmalloc (current_class_stack_size * sizeof (struct class_stack_node));
5427   VARRAY_TREE_INIT (local_classes, 8, "local_classes");
5428
5429   ridpointers[(int) RID_PUBLIC] = access_public_node;
5430   ridpointers[(int) RID_PRIVATE] = access_private_node;
5431   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5432 }
5433
5434 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5435    appropriate for TYPE.
5436
5437    So that we may avoid calls to lookup_name, we cache the _TYPE
5438    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5439
5440    For multiple inheritance, we perform a two-pass depth-first search
5441    of the type lattice.  The first pass performs a pre-order search,
5442    marking types after the type has had its fields installed in
5443    the appropriate IDENTIFIER_CLASS_VALUE slot.  The second pass merely
5444    unmarks the marked types.  If a field or member function name
5445    appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
5446    that name becomes `error_mark_node'.  */
5447
5448 void
5449 pushclass (tree type)
5450 {
5451   type = TYPE_MAIN_VARIANT (type);
5452
5453   /* Make sure there is enough room for the new entry on the stack.  */
5454   if (current_class_depth + 1 >= current_class_stack_size)
5455     {
5456       current_class_stack_size *= 2;
5457       current_class_stack
5458         = xrealloc (current_class_stack,
5459                     current_class_stack_size
5460                     * sizeof (struct class_stack_node));
5461     }
5462
5463   /* Insert a new entry on the class stack.  */
5464   current_class_stack[current_class_depth].name = current_class_name;
5465   current_class_stack[current_class_depth].type = current_class_type;
5466   current_class_stack[current_class_depth].access = current_access_specifier;
5467   current_class_stack[current_class_depth].names_used = 0;
5468   current_class_depth++;
5469
5470   /* Now set up the new type.  */
5471   current_class_name = TYPE_NAME (type);
5472   if (TREE_CODE (current_class_name) == TYPE_DECL)
5473     current_class_name = DECL_NAME (current_class_name);
5474   current_class_type = type;
5475
5476   /* By default, things in classes are private, while things in
5477      structures or unions are public.  */
5478   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5479                               ? access_private_node
5480                               : access_public_node);
5481
5482   if (previous_class_type != NULL_TREE
5483       && (type != previous_class_type
5484           || !COMPLETE_TYPE_P (previous_class_type))
5485       && current_class_depth == 1)
5486     {
5487       /* Forcibly remove any old class remnants.  */
5488       invalidate_class_lookup_cache ();
5489     }
5490
5491   /* If we're about to enter a nested class, clear
5492      IDENTIFIER_CLASS_VALUE for the enclosing classes.  */
5493   if (current_class_depth > 1)
5494     clear_identifier_class_values ();
5495
5496   pushlevel_class ();
5497
5498   if (type != previous_class_type || current_class_depth > 1)
5499     {
5500       push_class_decls (type);
5501       if (CLASSTYPE_TEMPLATE_INFO (type) && !CLASSTYPE_USE_TEMPLATE (type))
5502         {
5503           /* If we are entering the scope of a template declaration (not a
5504              specialization), we need to push all the using decls with
5505              dependent scope too.  */
5506           tree fields;
5507
5508           for (fields = TYPE_FIELDS (type);
5509                fields; fields = TREE_CHAIN (fields))
5510             if (TREE_CODE (fields) == USING_DECL && !TREE_TYPE (fields))
5511               pushdecl_class_level (fields);
5512         }
5513     }
5514   else
5515     {
5516       tree item;
5517
5518       /* We are re-entering the same class we just left, so we don't
5519          have to search the whole inheritance matrix to find all the
5520          decls to bind again.  Instead, we install the cached
5521          class_shadowed list, and walk through it binding names and
5522          setting up IDENTIFIER_TYPE_VALUEs.  */
5523       set_class_shadows (previous_class_values);
5524       for (item = previous_class_values; item; item = TREE_CHAIN (item))
5525         {
5526           tree id = TREE_PURPOSE (item);
5527           tree decl = TREE_TYPE (item);
5528
5529           push_class_binding (id, decl);
5530           if (TREE_CODE (decl) == TYPE_DECL)
5531             set_identifier_type_value (id, decl);
5532         }
5533       unuse_fields (type);
5534     }
5535
5536   cxx_remember_type_decls (CLASSTYPE_NESTED_UTDS (type));
5537 }
5538
5539 /* When we exit a toplevel class scope, we save the
5540    IDENTIFIER_CLASS_VALUEs so that we can restore them quickly if we
5541    reenter the class.  Here, we've entered some other class, so we
5542    must invalidate our cache.  */
5543
5544 void
5545 invalidate_class_lookup_cache (void)
5546 {
5547   tree t;
5548
5549   /* The IDENTIFIER_CLASS_VALUEs are no longer valid.  */
5550   for (t = previous_class_values; t; t = TREE_CHAIN (t))
5551     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
5552
5553   previous_class_values = NULL_TREE;
5554   previous_class_type = NULL_TREE;
5555 }
5556
5557 /* Get out of the current class scope. If we were in a class scope
5558    previously, that is the one popped to.  */
5559
5560 void
5561 popclass (void)
5562 {
5563   poplevel_class ();
5564   pop_class_decls ();
5565
5566   current_class_depth--;
5567   current_class_name = current_class_stack[current_class_depth].name;
5568   current_class_type = current_class_stack[current_class_depth].type;
5569   current_access_specifier = current_class_stack[current_class_depth].access;
5570   if (current_class_stack[current_class_depth].names_used)
5571     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5572 }
5573
5574 /* Returns 1 if current_class_type is either T or a nested type of T.
5575    We start looking from 1 because entry 0 is from global scope, and has
5576    no type.  */
5577
5578 int
5579 currently_open_class (tree t)
5580 {
5581   int i;
5582   if (current_class_type && same_type_p (t, current_class_type))
5583     return 1;
5584   for (i = 1; i < current_class_depth; ++i)
5585     if (current_class_stack[i].type
5586         && same_type_p (current_class_stack [i].type, t))
5587       return 1;
5588   return 0;
5589 }
5590
5591 /* If either current_class_type or one of its enclosing classes are derived
5592    from T, return the appropriate type.  Used to determine how we found
5593    something via unqualified lookup.  */
5594
5595 tree
5596 currently_open_derived_class (tree t)
5597 {
5598   int i;
5599
5600   /* The bases of a dependent type are unknown.  */
5601   if (dependent_type_p (t))
5602     return NULL_TREE;
5603
5604   if (!current_class_type)
5605     return NULL_TREE;
5606
5607   if (DERIVED_FROM_P (t, current_class_type))
5608     return current_class_type;
5609
5610   for (i = current_class_depth - 1; i > 0; --i)
5611     if (DERIVED_FROM_P (t, current_class_stack[i].type))
5612       return current_class_stack[i].type;
5613
5614   return NULL_TREE;
5615 }
5616
5617 /* When entering a class scope, all enclosing class scopes' names with
5618    static meaning (static variables, static functions, types and
5619    enumerators) have to be visible.  This recursive function calls
5620    pushclass for all enclosing class contexts until global or a local
5621    scope is reached.  TYPE is the enclosed class.  */
5622
5623 void
5624 push_nested_class (tree type)
5625 {
5626   tree context;
5627
5628   /* A namespace might be passed in error cases, like A::B:C.  */
5629   if (type == NULL_TREE
5630       || type == error_mark_node
5631       || TREE_CODE (type) == NAMESPACE_DECL
5632       || ! IS_AGGR_TYPE (type)
5633       || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5634       || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
5635     return;
5636
5637   context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
5638
5639   if (context && CLASS_TYPE_P (context))
5640     push_nested_class (context);
5641   pushclass (type);
5642 }
5643
5644 /* Undoes a push_nested_class call.  */
5645
5646 void
5647 pop_nested_class (void)
5648 {
5649   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5650
5651   popclass ();
5652   if (context && CLASS_TYPE_P (context))
5653     pop_nested_class ();
5654 }
5655
5656 /* Returns the number of extern "LANG" blocks we are nested within.  */
5657
5658 int
5659 current_lang_depth (void)
5660 {
5661   return VARRAY_ACTIVE_SIZE (current_lang_base);
5662 }
5663
5664 /* Set global variables CURRENT_LANG_NAME to appropriate value
5665    so that behavior of name-mangling machinery is correct.  */
5666
5667 void
5668 push_lang_context (tree name)
5669 {
5670   VARRAY_PUSH_TREE (current_lang_base, current_lang_name);
5671
5672   if (name == lang_name_cplusplus)
5673     {
5674       current_lang_name = name;
5675     }
5676   else if (name == lang_name_java)
5677     {
5678       current_lang_name = name;
5679       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5680          (See record_builtin_java_type in decl.c.)  However, that causes
5681          incorrect debug entries if these types are actually used.
5682          So we re-enable debug output after extern "Java".  */
5683       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5684       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5685       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5686       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5687       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5688       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5689       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5690       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5691     }
5692   else if (name == lang_name_c)
5693     {
5694       current_lang_name = name;
5695     }
5696   else
5697     error ("language string `\"%s\"' not recognized", IDENTIFIER_POINTER (name));
5698 }
5699
5700 /* Get out of the current language scope.  */
5701
5702 void
5703 pop_lang_context (void)
5704 {
5705   current_lang_name = VARRAY_TOP_TREE (current_lang_base);
5706   VARRAY_POP (current_lang_base);
5707 }
5708 \f
5709 /* Type instantiation routines.  */
5710
5711 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5712    matches the TARGET_TYPE.  If there is no satisfactory match, return
5713    error_mark_node, and issue a error & warning messages under control
5714    of FLAGS.  Permit pointers to member function if FLAGS permits.  If
5715    TEMPLATE_ONLY, the name of the overloaded function was a
5716    template-id, and EXPLICIT_TARGS are the explicitly provided
5717    template arguments.  */
5718
5719 static tree
5720 resolve_address_of_overloaded_function (tree target_type,
5721                                         tree overload,
5722                                         tsubst_flags_t flags,
5723                                         bool template_only,
5724                                         tree explicit_targs)
5725 {
5726   /* Here's what the standard says:
5727
5728        [over.over]
5729
5730        If the name is a function template, template argument deduction
5731        is done, and if the argument deduction succeeds, the deduced
5732        arguments are used to generate a single template function, which
5733        is added to the set of overloaded functions considered.
5734
5735        Non-member functions and static member functions match targets of
5736        type "pointer-to-function" or "reference-to-function."  Nonstatic
5737        member functions match targets of type "pointer-to-member
5738        function;" the function type of the pointer to member is used to
5739        select the member function from the set of overloaded member
5740        functions.  If a nonstatic member function is selected, the
5741        reference to the overloaded function name is required to have the
5742        form of a pointer to member as described in 5.3.1.
5743
5744        If more than one function is selected, any template functions in
5745        the set are eliminated if the set also contains a non-template
5746        function, and any given template function is eliminated if the
5747        set contains a second template function that is more specialized
5748        than the first according to the partial ordering rules 14.5.5.2.
5749        After such eliminations, if any, there shall remain exactly one
5750        selected function.  */
5751
5752   int is_ptrmem = 0;
5753   int is_reference = 0;
5754   /* We store the matches in a TREE_LIST rooted here.  The functions
5755      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5756      interoperability with most_specialized_instantiation.  */
5757   tree matches = NULL_TREE;
5758   tree fn;
5759
5760   /* By the time we get here, we should be seeing only real
5761      pointer-to-member types, not the internal POINTER_TYPE to
5762      METHOD_TYPE representation.  */
5763   my_friendly_assert (!(TREE_CODE (target_type) == POINTER_TYPE
5764                         && (TREE_CODE (TREE_TYPE (target_type))
5765                             == METHOD_TYPE)), 0);
5766
5767   my_friendly_assert (is_overloaded_fn (overload), 20030910);
5768
5769   /* Check that the TARGET_TYPE is reasonable.  */
5770   if (TYPE_PTRFN_P (target_type))
5771     /* This is OK.  */;
5772   else if (TYPE_PTRMEMFUNC_P (target_type))
5773     /* This is OK, too.  */
5774     is_ptrmem = 1;
5775   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5776     {
5777       /* This is OK, too.  This comes from a conversion to reference
5778          type.  */
5779       target_type = build_reference_type (target_type);
5780       is_reference = 1;
5781     }
5782   else
5783     {
5784       if (flags & tf_error)
5785         error ("\
5786 cannot resolve overloaded function `%D' based on conversion to type `%T'",
5787                   DECL_NAME (OVL_FUNCTION (overload)), target_type);
5788       return error_mark_node;
5789     }
5790
5791   /* If we can find a non-template function that matches, we can just
5792      use it.  There's no point in generating template instantiations
5793      if we're just going to throw them out anyhow.  But, of course, we
5794      can only do this when we don't *need* a template function.  */
5795   if (!template_only)
5796     {
5797       tree fns;
5798
5799       for (fns = overload; fns; fns = OVL_NEXT (fns))
5800         {
5801           tree fn = OVL_CURRENT (fns);
5802           tree fntype;
5803
5804           if (TREE_CODE (fn) == TEMPLATE_DECL)
5805             /* We're not looking for templates just yet.  */
5806             continue;
5807
5808           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5809               != is_ptrmem)
5810             /* We're looking for a non-static member, and this isn't
5811                one, or vice versa.  */
5812             continue;
5813
5814           /* Ignore anticipated decls of undeclared builtins.  */
5815           if (DECL_ANTICIPATED (fn))
5816             continue;
5817
5818           /* See if there's a match.  */
5819           fntype = TREE_TYPE (fn);
5820           if (is_ptrmem)
5821             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5822           else if (!is_reference)
5823             fntype = build_pointer_type (fntype);
5824
5825           if (can_convert_arg (target_type, fntype, fn))
5826             matches = tree_cons (fn, NULL_TREE, matches);
5827         }
5828     }
5829
5830   /* Now, if we've already got a match (or matches), there's no need
5831      to proceed to the template functions.  But, if we don't have a
5832      match we need to look at them, too.  */
5833   if (!matches)
5834     {
5835       tree target_fn_type;
5836       tree target_arg_types;
5837       tree target_ret_type;
5838       tree fns;
5839
5840       if (is_ptrmem)
5841         target_fn_type
5842           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5843       else
5844         target_fn_type = TREE_TYPE (target_type);
5845       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5846       target_ret_type = TREE_TYPE (target_fn_type);
5847
5848       /* Never do unification on the 'this' parameter.  */
5849       if (TREE_CODE (target_fn_type) == METHOD_TYPE)
5850         target_arg_types = TREE_CHAIN (target_arg_types);
5851
5852       for (fns = overload; fns; fns = OVL_NEXT (fns))
5853         {
5854           tree fn = OVL_CURRENT (fns);
5855           tree instantiation;
5856           tree instantiation_type;
5857           tree targs;
5858
5859           if (TREE_CODE (fn) != TEMPLATE_DECL)
5860             /* We're only looking for templates.  */
5861             continue;
5862
5863           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5864               != is_ptrmem)
5865             /* We're not looking for a non-static member, and this is
5866                one, or vice versa.  */
5867             continue;
5868
5869           /* Try to do argument deduction.  */
5870           targs = make_tree_vec (DECL_NTPARMS (fn));
5871           if (fn_type_unification (fn, explicit_targs, targs,
5872                                    target_arg_types, target_ret_type,
5873                                    DEDUCE_EXACT, -1) != 0)
5874             /* Argument deduction failed.  */
5875             continue;
5876
5877           /* Instantiate the template.  */
5878           instantiation = instantiate_template (fn, targs, flags);
5879           if (instantiation == error_mark_node)
5880             /* Instantiation failed.  */
5881             continue;
5882
5883           /* See if there's a match.  */
5884           instantiation_type = TREE_TYPE (instantiation);
5885           if (is_ptrmem)
5886             instantiation_type =
5887               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
5888           else if (!is_reference)
5889             instantiation_type = build_pointer_type (instantiation_type);
5890           if (can_convert_arg (target_type, instantiation_type, instantiation))
5891             matches = tree_cons (instantiation, fn, matches);
5892         }
5893
5894       /* Now, remove all but the most specialized of the matches.  */
5895       if (matches)
5896         {
5897           tree match = most_specialized_instantiation (matches);
5898
5899           if (match != error_mark_node)
5900             matches = tree_cons (match, NULL_TREE, NULL_TREE);
5901         }
5902     }
5903
5904   /* Now we should have exactly one function in MATCHES.  */
5905   if (matches == NULL_TREE)
5906     {
5907       /* There were *no* matches.  */
5908       if (flags & tf_error)
5909         {
5910           error ("no matches converting function `%D' to type `%#T'",
5911                     DECL_NAME (OVL_FUNCTION (overload)),
5912                     target_type);
5913
5914           /* print_candidates expects a chain with the functions in
5915              TREE_VALUE slots, so we cons one up here (we're losing anyway,
5916              so why be clever?).  */
5917           for (; overload; overload = OVL_NEXT (overload))
5918             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
5919                                  matches);
5920
5921           print_candidates (matches);
5922         }
5923       return error_mark_node;
5924     }
5925   else if (TREE_CHAIN (matches))
5926     {
5927       /* There were too many matches.  */
5928
5929       if (flags & tf_error)
5930         {
5931           tree match;
5932
5933           error ("converting overloaded function `%D' to type `%#T' is ambiguous",
5934                     DECL_NAME (OVL_FUNCTION (overload)),
5935                     target_type);
5936
5937           /* Since print_candidates expects the functions in the
5938              TREE_VALUE slot, we flip them here.  */
5939           for (match = matches; match; match = TREE_CHAIN (match))
5940             TREE_VALUE (match) = TREE_PURPOSE (match);
5941
5942           print_candidates (matches);
5943         }
5944
5945       return error_mark_node;
5946     }
5947
5948   /* Good, exactly one match.  Now, convert it to the correct type.  */
5949   fn = TREE_PURPOSE (matches);
5950
5951   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
5952       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
5953     {
5954       static int explained;
5955
5956       if (!(flags & tf_error))
5957         return error_mark_node;
5958
5959       pedwarn ("assuming pointer to member `%D'", fn);
5960       if (!explained)
5961         {
5962           pedwarn ("(a pointer to member can only be formed with `&%E')", fn);
5963           explained = 1;
5964         }
5965     }
5966
5967   /* If we're doing overload resolution purely for the purpose of
5968      determining conversion sequences, we should not consider the
5969      function used.  If this conversion sequence is selected, the
5970      function will be marked as used at this point.  */
5971   if (!(flags & tf_conv))
5972     mark_used (fn);
5973
5974   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
5975     return build_unary_op (ADDR_EXPR, fn, 0);
5976   else
5977     {
5978       /* The target must be a REFERENCE_TYPE.  Above, build_unary_op
5979          will mark the function as addressed, but here we must do it
5980          explicitly.  */
5981       cxx_mark_addressable (fn);
5982
5983       return fn;
5984     }
5985 }
5986
5987 /* This function will instantiate the type of the expression given in
5988    RHS to match the type of LHSTYPE.  If errors exist, then return
5989    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
5990    we complain on errors.  If we are not complaining, never modify rhs,
5991    as overload resolution wants to try many possible instantiations, in
5992    the hope that at least one will work.
5993
5994    For non-recursive calls, LHSTYPE should be a function, pointer to
5995    function, or a pointer to member function.  */
5996
5997 tree
5998 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
5999 {
6000   tsubst_flags_t flags_in = flags;
6001
6002   flags &= ~tf_ptrmem_ok;
6003
6004   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
6005     {
6006       if (flags & tf_error)
6007         error ("not enough type information");
6008       return error_mark_node;
6009     }
6010
6011   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6012     {
6013       if (same_type_p (lhstype, TREE_TYPE (rhs)))
6014         return rhs;
6015       if (flag_ms_extensions
6016           && TYPE_PTRMEMFUNC_P (lhstype)
6017           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6018         /* Microsoft allows `A::f' to be resolved to a
6019            pointer-to-member.  */
6020         ;
6021       else
6022         {
6023           if (flags & tf_error)
6024             error ("argument of type `%T' does not match `%T'",
6025                    TREE_TYPE (rhs), lhstype);
6026           return error_mark_node;
6027         }
6028     }
6029
6030   if (TREE_CODE (rhs) == BASELINK)
6031     rhs = BASELINK_FUNCTIONS (rhs);
6032
6033   /* We don't overwrite rhs if it is an overloaded function.
6034      Copying it would destroy the tree link.  */
6035   if (TREE_CODE (rhs) != OVERLOAD)
6036     rhs = copy_node (rhs);
6037
6038   /* This should really only be used when attempting to distinguish
6039      what sort of a pointer to function we have.  For now, any
6040      arithmetic operation which is not supported on pointers
6041      is rejected as an error.  */
6042
6043   switch (TREE_CODE (rhs))
6044     {
6045     case TYPE_EXPR:
6046     case CONVERT_EXPR:
6047     case SAVE_EXPR:
6048     case CONSTRUCTOR:
6049     case BUFFER_REF:
6050       abort ();
6051       return error_mark_node;
6052
6053     case INDIRECT_REF:
6054     case ARRAY_REF:
6055       {
6056         tree new_rhs;
6057
6058         new_rhs = instantiate_type (build_pointer_type (lhstype),
6059                                     TREE_OPERAND (rhs, 0), flags);
6060         if (new_rhs == error_mark_node)
6061           return error_mark_node;
6062
6063         TREE_TYPE (rhs) = lhstype;
6064         TREE_OPERAND (rhs, 0) = new_rhs;
6065         return rhs;
6066       }
6067
6068     case NOP_EXPR:
6069       rhs = copy_node (TREE_OPERAND (rhs, 0));
6070       TREE_TYPE (rhs) = unknown_type_node;
6071       return instantiate_type (lhstype, rhs, flags);
6072
6073     case COMPONENT_REF:
6074       {
6075         tree addr = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6076
6077         if (addr != error_mark_node
6078             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6079           /* Do not lose object's side effects.  */
6080           addr = build (COMPOUND_EXPR, TREE_TYPE (addr),
6081                         TREE_OPERAND (rhs, 0), addr);
6082         return addr;
6083       }
6084
6085     case OFFSET_REF:
6086       rhs = TREE_OPERAND (rhs, 1);
6087       if (BASELINK_P (rhs))
6088         return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags_in);
6089
6090       /* This can happen if we are forming a pointer-to-member for a
6091          member template.  */
6092       my_friendly_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR, 0);
6093
6094       /* Fall through.  */
6095
6096     case TEMPLATE_ID_EXPR:
6097       {
6098         tree fns = TREE_OPERAND (rhs, 0);
6099         tree args = TREE_OPERAND (rhs, 1);
6100
6101         return
6102           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6103                                                   /*template_only=*/true,
6104                                                   args);
6105       }
6106
6107     case OVERLOAD:
6108     case FUNCTION_DECL:
6109       return
6110         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6111                                                 /*template_only=*/false,
6112                                                 /*explicit_targs=*/NULL_TREE);
6113
6114     case TREE_LIST:
6115       /* Now we should have a baselink.  */
6116       my_friendly_assert (BASELINK_P (rhs), 990412);
6117
6118       return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags);
6119
6120     case CALL_EXPR:
6121       /* This is too hard for now.  */
6122       abort ();
6123       return error_mark_node;
6124
6125     case PLUS_EXPR:
6126     case MINUS_EXPR:
6127     case COMPOUND_EXPR:
6128       TREE_OPERAND (rhs, 0)
6129         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6130       if (TREE_OPERAND (rhs, 0) == error_mark_node)
6131         return error_mark_node;
6132       TREE_OPERAND (rhs, 1)
6133         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6134       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6135         return error_mark_node;
6136
6137       TREE_TYPE (rhs) = lhstype;
6138       return rhs;
6139
6140     case MULT_EXPR:
6141     case TRUNC_DIV_EXPR:
6142     case FLOOR_DIV_EXPR:
6143     case CEIL_DIV_EXPR:
6144     case ROUND_DIV_EXPR:
6145     case RDIV_EXPR:
6146     case TRUNC_MOD_EXPR:
6147     case FLOOR_MOD_EXPR:
6148     case CEIL_MOD_EXPR:
6149     case ROUND_MOD_EXPR:
6150     case FIX_ROUND_EXPR:
6151     case FIX_FLOOR_EXPR:
6152     case FIX_CEIL_EXPR:
6153     case FIX_TRUNC_EXPR:
6154     case FLOAT_EXPR:
6155     case NEGATE_EXPR:
6156     case ABS_EXPR:
6157     case MAX_EXPR:
6158     case MIN_EXPR:
6159
6160     case BIT_AND_EXPR:
6161     case BIT_IOR_EXPR:
6162     case BIT_XOR_EXPR:
6163     case LSHIFT_EXPR:
6164     case RSHIFT_EXPR:
6165     case LROTATE_EXPR:
6166     case RROTATE_EXPR:
6167
6168     case PREINCREMENT_EXPR:
6169     case PREDECREMENT_EXPR:
6170     case POSTINCREMENT_EXPR:
6171     case POSTDECREMENT_EXPR:
6172       if (flags & tf_error)
6173         error ("invalid operation on uninstantiated type");
6174       return error_mark_node;
6175
6176     case TRUTH_AND_EXPR:
6177     case TRUTH_OR_EXPR:
6178     case TRUTH_XOR_EXPR:
6179     case LT_EXPR:
6180     case LE_EXPR:
6181     case GT_EXPR:
6182     case GE_EXPR:
6183     case EQ_EXPR:
6184     case NE_EXPR:
6185     case TRUTH_ANDIF_EXPR:
6186     case TRUTH_ORIF_EXPR:
6187     case TRUTH_NOT_EXPR:
6188       if (flags & tf_error)
6189         error ("not enough type information");
6190       return error_mark_node;
6191
6192     case COND_EXPR:
6193       if (type_unknown_p (TREE_OPERAND (rhs, 0)))
6194         {
6195           if (flags & tf_error)
6196             error ("not enough type information");
6197           return error_mark_node;
6198         }
6199       TREE_OPERAND (rhs, 1)
6200         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6201       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6202         return error_mark_node;
6203       TREE_OPERAND (rhs, 2)
6204         = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), flags);
6205       if (TREE_OPERAND (rhs, 2) == error_mark_node)
6206         return error_mark_node;
6207
6208       TREE_TYPE (rhs) = lhstype;
6209       return rhs;
6210
6211     case MODIFY_EXPR:
6212       TREE_OPERAND (rhs, 1)
6213         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6214       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6215         return error_mark_node;
6216
6217       TREE_TYPE (rhs) = lhstype;
6218       return rhs;
6219
6220     case ADDR_EXPR:
6221     {
6222       if (PTRMEM_OK_P (rhs))
6223         flags |= tf_ptrmem_ok;
6224
6225       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6226     }
6227     case ENTRY_VALUE_EXPR:
6228       abort ();
6229       return error_mark_node;
6230
6231     case ERROR_MARK:
6232       return error_mark_node;
6233
6234     default:
6235       abort ();
6236       return error_mark_node;
6237     }
6238 }
6239 \f
6240 /* Return the name of the virtual function pointer field
6241    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6242    this may have to look back through base types to find the
6243    ultimate field name.  (For single inheritance, these could
6244    all be the same name.  Who knows for multiple inheritance).  */
6245
6246 static tree
6247 get_vfield_name (tree type)
6248 {
6249   tree binfo = TYPE_BINFO (type);
6250   char *buf;
6251
6252   while (BINFO_BASETYPES (binfo)
6253          && TYPE_CONTAINS_VPTR_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0)))
6254          && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0)))
6255     binfo = BINFO_BASETYPE (binfo, 0);
6256
6257   type = BINFO_TYPE (binfo);
6258   buf = alloca (sizeof (VFIELD_NAME_FORMAT) + TYPE_NAME_LENGTH (type) + 2);
6259   sprintf (buf, VFIELD_NAME_FORMAT,
6260            IDENTIFIER_POINTER (constructor_name (type)));
6261   return get_identifier (buf);
6262 }
6263
6264 void
6265 print_class_statistics (void)
6266 {
6267 #ifdef GATHER_STATISTICS
6268   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6269   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6270   if (n_vtables)
6271     {
6272       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6273                n_vtables, n_vtable_searches);
6274       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6275                n_vtable_entries, n_vtable_elems);
6276     }
6277 #endif
6278 }
6279
6280 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6281    according to [class]:
6282                                           The class-name is also inserted
6283    into  the scope of the class itself.  For purposes of access checking,
6284    the inserted class name is treated as if it were a public member name.  */
6285
6286 void
6287 build_self_reference (void)
6288 {
6289   tree name = constructor_name (current_class_type);
6290   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6291   tree saved_cas;
6292
6293   DECL_NONLOCAL (value) = 1;
6294   DECL_CONTEXT (value) = current_class_type;
6295   DECL_ARTIFICIAL (value) = 1;
6296   SET_DECL_SELF_REFERENCE_P (value);
6297
6298   if (processing_template_decl)
6299     value = push_template_decl (value);
6300
6301   saved_cas = current_access_specifier;
6302   current_access_specifier = access_public_node;
6303   finish_member_declaration (value);
6304   current_access_specifier = saved_cas;
6305 }
6306
6307 /* Returns 1 if TYPE contains only padding bytes.  */
6308
6309 int
6310 is_empty_class (tree type)
6311 {
6312   if (type == error_mark_node)
6313     return 0;
6314
6315   if (! IS_AGGR_TYPE (type))
6316     return 0;
6317
6318   /* In G++ 3.2, whether or not a class was empty was determined by
6319      looking at its size.  */
6320   if (abi_version_at_least (2))
6321     return CLASSTYPE_EMPTY_P (type);
6322   else
6323     return integer_zerop (CLASSTYPE_SIZE (type));
6324 }
6325
6326 /* Returns true if TYPE contains an empty class.  */
6327
6328 static bool
6329 contains_empty_class_p (tree type)
6330 {
6331   if (is_empty_class (type))
6332     return true;
6333   if (CLASS_TYPE_P (type))
6334     {
6335       tree field;
6336       int i;
6337
6338       for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); ++i)
6339         if (contains_empty_class_p (TYPE_BINFO_BASETYPE (type, i)))
6340           return true;
6341       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6342         if (TREE_CODE (field) == FIELD_DECL
6343             && !DECL_ARTIFICIAL (field)
6344             && is_empty_class (TREE_TYPE (field)))
6345           return true;
6346     }
6347   else if (TREE_CODE (type) == ARRAY_TYPE)
6348     return contains_empty_class_p (TREE_TYPE (type));
6349   return false;
6350 }
6351
6352 /* Find the enclosing class of the given NODE.  NODE can be a *_DECL or
6353    a *_TYPE node.  NODE can also be a local class.  */
6354
6355 tree
6356 get_enclosing_class (tree type)
6357 {
6358   tree node = type;
6359
6360   while (node && TREE_CODE (node) != NAMESPACE_DECL)
6361     {
6362       switch (TREE_CODE_CLASS (TREE_CODE (node)))
6363         {
6364         case 'd':
6365           node = DECL_CONTEXT (node);
6366           break;
6367
6368         case 't':
6369           if (node != type)
6370             return node;
6371           node = TYPE_CONTEXT (node);
6372           break;
6373
6374         default:
6375           abort ();
6376         }
6377     }
6378   return NULL_TREE;
6379 }
6380
6381 /* Note that NAME was looked up while the current class was being
6382    defined and that the result of that lookup was DECL.  */
6383
6384 void
6385 maybe_note_name_used_in_class (tree name, tree decl)
6386 {
6387   splay_tree names_used;
6388
6389   /* If we're not defining a class, there's nothing to do.  */
6390   if (innermost_scope_kind() != sk_class)
6391     return;
6392
6393   /* If there's already a binding for this NAME, then we don't have
6394      anything to worry about.  */
6395   if (IDENTIFIER_CLASS_VALUE (name))
6396     return;
6397
6398   if (!current_class_stack[current_class_depth - 1].names_used)
6399     current_class_stack[current_class_depth - 1].names_used
6400       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6401   names_used = current_class_stack[current_class_depth - 1].names_used;
6402
6403   splay_tree_insert (names_used,
6404                      (splay_tree_key) name,
6405                      (splay_tree_value) decl);
6406 }
6407
6408 /* Note that NAME was declared (as DECL) in the current class.  Check
6409    to see that the declaration is valid.  */
6410
6411 void
6412 note_name_declared_in_class (tree name, tree decl)
6413 {
6414   splay_tree names_used;
6415   splay_tree_node n;
6416
6417   /* Look to see if we ever used this name.  */
6418   names_used
6419     = current_class_stack[current_class_depth - 1].names_used;
6420   if (!names_used)
6421     return;
6422
6423   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6424   if (n)
6425     {
6426       /* [basic.scope.class]
6427
6428          A name N used in a class S shall refer to the same declaration
6429          in its context and when re-evaluated in the completed scope of
6430          S.  */
6431       error ("declaration of `%#D'", decl);
6432       cp_error_at ("changes meaning of `%D' from `%+#D'",
6433                    DECL_NAME (OVL_CURRENT (decl)),
6434                    (tree) n->value);
6435     }
6436 }
6437
6438 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6439    Secondary vtables are merged with primary vtables; this function
6440    will return the VAR_DECL for the primary vtable.  */
6441
6442 tree
6443 get_vtbl_decl_for_binfo (tree binfo)
6444 {
6445   tree decl;
6446
6447   decl = BINFO_VTABLE (binfo);
6448   if (decl && TREE_CODE (decl) == PLUS_EXPR)
6449     {
6450       my_friendly_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR,
6451                           2000403);
6452       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6453     }
6454   if (decl)
6455     my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20000403);
6456   return decl;
6457 }
6458
6459
6460 /* Returns the binfo for the primary base of BINFO.  If the resulting
6461    BINFO is a virtual base, and it is inherited elsewhere in the
6462    hierarchy, then the returned binfo might not be the primary base of
6463    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6464    BINFO_LOST_PRIMARY_P to be sure.  */
6465
6466 tree
6467 get_primary_binfo (tree binfo)
6468 {
6469   tree primary_base;
6470   tree result;
6471
6472   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6473   if (!primary_base)
6474     return NULL_TREE;
6475
6476   result = copied_binfo (primary_base, binfo);
6477   return result;
6478 }
6479
6480 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6481
6482 static int
6483 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6484 {
6485   if (!indented_p)
6486     fprintf (stream, "%*s", indent, "");
6487   return 1;
6488 }
6489
6490 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6491    INDENT should be zero when called from the top level; it is
6492    incremented recursively.  IGO indicates the next expected BINFO in
6493    inheritance graph ordering.  */
6494
6495 static tree
6496 dump_class_hierarchy_r (FILE *stream,
6497                         int flags,
6498                         tree binfo,
6499                         tree igo,
6500                         int indent)
6501 {
6502   int indented = 0;
6503   tree base_binfos;
6504
6505   indented = maybe_indent_hierarchy (stream, indent, 0);
6506   fprintf (stream, "%s (0x%lx) ",
6507            type_as_string (binfo, TFF_PLAIN_IDENTIFIER),
6508            (unsigned long) binfo);
6509   if (binfo != igo)
6510     {
6511       fprintf (stream, "alternative-path\n");
6512       return igo;
6513     }
6514   igo = TREE_CHAIN (binfo);
6515
6516   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6517            tree_low_cst (BINFO_OFFSET (binfo), 0));
6518   if (is_empty_class (BINFO_TYPE (binfo)))
6519     fprintf (stream, " empty");
6520   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6521     fprintf (stream, " nearly-empty");
6522   if (TREE_VIA_VIRTUAL (binfo))
6523     fprintf (stream, " virtual");
6524   fprintf (stream, "\n");
6525
6526   indented = 0;
6527   if (BINFO_PRIMARY_BASE_OF (binfo))
6528     {
6529       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6530       fprintf (stream, " primary-for %s (0x%lx)",
6531                type_as_string (BINFO_PRIMARY_BASE_OF (binfo),
6532                                TFF_PLAIN_IDENTIFIER),
6533                (unsigned long)BINFO_PRIMARY_BASE_OF (binfo));
6534     }
6535   if (BINFO_LOST_PRIMARY_P (binfo))
6536     {
6537       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6538       fprintf (stream, " lost-primary");
6539     }
6540   if (indented)
6541     fprintf (stream, "\n");
6542
6543   if (!(flags & TDF_SLIM))
6544     {
6545       int indented = 0;
6546
6547       if (BINFO_SUBVTT_INDEX (binfo))
6548         {
6549           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6550           fprintf (stream, " subvttidx=%s",
6551                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6552                                    TFF_PLAIN_IDENTIFIER));
6553         }
6554       if (BINFO_VPTR_INDEX (binfo))
6555         {
6556           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6557           fprintf (stream, " vptridx=%s",
6558                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6559                                    TFF_PLAIN_IDENTIFIER));
6560         }
6561       if (BINFO_VPTR_FIELD (binfo))
6562         {
6563           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6564           fprintf (stream, " vbaseoffset=%s",
6565                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6566                                    TFF_PLAIN_IDENTIFIER));
6567         }
6568       if (BINFO_VTABLE (binfo))
6569         {
6570           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6571           fprintf (stream, " vptr=%s",
6572                    expr_as_string (BINFO_VTABLE (binfo),
6573                                    TFF_PLAIN_IDENTIFIER));
6574         }
6575
6576       if (indented)
6577         fprintf (stream, "\n");
6578     }
6579
6580   base_binfos = BINFO_BASETYPES (binfo);
6581   if (base_binfos)
6582     {
6583       int ix, n;
6584
6585       n = TREE_VEC_LENGTH (base_binfos);
6586       for (ix = 0; ix != n; ix++)
6587         {
6588           tree base_binfo = TREE_VEC_ELT (base_binfos, ix);
6589
6590           igo = dump_class_hierarchy_r (stream, flags, base_binfo,
6591                                         igo, indent + 2);
6592         }
6593     }
6594
6595   return igo;
6596 }
6597
6598 /* Dump the BINFO hierarchy for T.  */
6599
6600 static void
6601 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6602 {
6603   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6604   fprintf (stream, "   size=%lu align=%lu\n",
6605            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6606            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6607   fprintf (stream, "   base size=%lu base align=%lu\n",
6608            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6609                            / BITS_PER_UNIT),
6610            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6611                            / BITS_PER_UNIT));
6612   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6613   fprintf (stream, "\n");
6614 }
6615
6616 /* Debug interface to hierarchy dumping.  */
6617
6618 extern void
6619 debug_class (tree t)
6620 {
6621   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6622 }
6623
6624 static void
6625 dump_class_hierarchy (tree t)
6626 {
6627   int flags;
6628   FILE *stream = dump_begin (TDI_class, &flags);
6629
6630   if (stream)
6631     {
6632       dump_class_hierarchy_1 (stream, flags, t);
6633       dump_end (TDI_class, stream);
6634     }
6635 }
6636
6637 static void
6638 dump_array (FILE * stream, tree decl)
6639 {
6640   tree inits;
6641   int ix;
6642   HOST_WIDE_INT elt;
6643   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6644
6645   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6646          / BITS_PER_UNIT);
6647   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6648   fprintf (stream, " %s entries",
6649            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6650                            TFF_PLAIN_IDENTIFIER));
6651   fprintf (stream, "\n");
6652
6653   for (ix = 0, inits = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
6654        inits; ix++, inits = TREE_CHAIN (inits))
6655     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6656              expr_as_string (TREE_VALUE (inits), TFF_PLAIN_IDENTIFIER));
6657 }
6658
6659 static void
6660 dump_vtable (tree t, tree binfo, tree vtable)
6661 {
6662   int flags;
6663   FILE *stream = dump_begin (TDI_class, &flags);
6664
6665   if (!stream)
6666     return;
6667
6668   if (!(flags & TDF_SLIM))
6669     {
6670       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6671
6672       fprintf (stream, "%s for %s",
6673                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6674                type_as_string (binfo, TFF_PLAIN_IDENTIFIER));
6675       if (ctor_vtbl_p)
6676         {
6677           if (!TREE_VIA_VIRTUAL (binfo))
6678             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6679           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6680         }
6681       fprintf (stream, "\n");
6682       dump_array (stream, vtable);
6683       fprintf (stream, "\n");
6684     }
6685
6686   dump_end (TDI_class, stream);
6687 }
6688
6689 static void
6690 dump_vtt (tree t, tree vtt)
6691 {
6692   int flags;
6693   FILE *stream = dump_begin (TDI_class, &flags);
6694
6695   if (!stream)
6696     return;
6697
6698   if (!(flags & TDF_SLIM))
6699     {
6700       fprintf (stream, "VTT for %s\n",
6701                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6702       dump_array (stream, vtt);
6703       fprintf (stream, "\n");
6704     }
6705
6706   dump_end (TDI_class, stream);
6707 }
6708
6709 /* Dump a function or thunk and its thunkees.  */
6710
6711 static void
6712 dump_thunk (FILE *stream, int indent, tree thunk)
6713 {
6714   static const char spaces[] = "        ";
6715   tree name = DECL_NAME (thunk);
6716   tree thunks;
6717
6718   fprintf (stream, "%.*s%p %s %s", indent, spaces,
6719            (void *)thunk,
6720            !DECL_THUNK_P (thunk) ? "function"
6721            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6722            name ? IDENTIFIER_POINTER (name) : "<unset>");
6723   if (DECL_THUNK_P (thunk))
6724     {
6725       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6726       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6727
6728       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6729       if (!virtual_adjust)
6730         /*NOP*/;
6731       else if (DECL_THIS_THUNK_P (thunk))
6732         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
6733                  tree_low_cst (virtual_adjust, 0));
6734       else
6735         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6736                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6737                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6738       if (THUNK_ALIAS (thunk))
6739         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6740     }
6741   fprintf (stream, "\n");
6742   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6743     dump_thunk (stream, indent + 2, thunks);
6744 }
6745
6746 /* Dump the thunks for FN.  */
6747
6748 extern void
6749 debug_thunks (tree fn)
6750 {
6751   dump_thunk (stderr, 0, fn);
6752 }
6753
6754 /* Virtual function table initialization.  */
6755
6756 /* Create all the necessary vtables for T and its base classes.  */
6757
6758 static void
6759 finish_vtbls (tree t)
6760 {
6761   tree list;
6762   tree vbase;
6763
6764   /* We lay out the primary and secondary vtables in one contiguous
6765      vtable.  The primary vtable is first, followed by the non-virtual
6766      secondary vtables in inheritance graph order.  */
6767   list = build_tree_list (TYPE_BINFO_VTABLE (t), NULL_TREE);
6768   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6769                          TYPE_BINFO (t), t, list);
6770
6771   /* Then come the virtual bases, also in inheritance graph order.  */
6772   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6773     {
6774       if (!TREE_VIA_VIRTUAL (vbase))
6775         continue;
6776       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6777     }
6778
6779   if (TYPE_BINFO_VTABLE (t))
6780     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6781 }
6782
6783 /* Initialize the vtable for BINFO with the INITS.  */
6784
6785 static void
6786 initialize_vtable (tree binfo, tree inits)
6787 {
6788   tree decl;
6789
6790   layout_vtable_decl (binfo, list_length (inits));
6791   decl = get_vtbl_decl_for_binfo (binfo);
6792   initialize_array (decl, inits);
6793   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6794 }
6795
6796 /* Initialize DECL (a declaration for a namespace-scope array) with
6797    the INITS.  */
6798
6799 static void
6800 initialize_array (tree decl, tree inits)
6801 {
6802   tree context;
6803
6804   context = DECL_CONTEXT (decl);
6805   DECL_CONTEXT (decl) = NULL_TREE;
6806   DECL_INITIAL (decl) = build_constructor (NULL_TREE, inits);
6807   TREE_HAS_CONSTRUCTOR (DECL_INITIAL (decl)) = 1;
6808   cp_finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0);
6809   DECL_CONTEXT (decl) = context;
6810 }
6811
6812 /* Build the VTT (virtual table table) for T.
6813    A class requires a VTT if it has virtual bases.
6814
6815    This holds
6816    1 - primary virtual pointer for complete object T
6817    2 - secondary VTTs for each direct non-virtual base of T which requires a
6818        VTT
6819    3 - secondary virtual pointers for each direct or indirect base of T which
6820        has virtual bases or is reachable via a virtual path from T.
6821    4 - secondary VTTs for each direct or indirect virtual base of T.
6822
6823    Secondary VTTs look like complete object VTTs without part 4.  */
6824
6825 static void
6826 build_vtt (tree t)
6827 {
6828   tree inits;
6829   tree type;
6830   tree vtt;
6831   tree index;
6832
6833   /* Build up the initializers for the VTT.  */
6834   inits = NULL_TREE;
6835   index = size_zero_node;
6836   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6837
6838   /* If we didn't need a VTT, we're done.  */
6839   if (!inits)
6840     return;
6841
6842   /* Figure out the type of the VTT.  */
6843   type = build_index_type (size_int (list_length (inits) - 1));
6844   type = build_cplus_array_type (const_ptr_type_node, type);
6845
6846   /* Now, build the VTT object itself.  */
6847   vtt = build_vtable (t, get_vtt_name (t), type);
6848   initialize_array (vtt, inits);
6849   /* Add the VTT to the vtables list.  */
6850   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6851   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6852
6853   dump_vtt (t, vtt);
6854 }
6855
6856 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6857    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6858    and CHAIN the vtable pointer for this binfo after construction is
6859    complete.  VALUE can also be another BINFO, in which case we recurse.  */
6860
6861 static tree
6862 binfo_ctor_vtable (tree binfo)
6863 {
6864   tree vt;
6865
6866   while (1)
6867     {
6868       vt = BINFO_VTABLE (binfo);
6869       if (TREE_CODE (vt) == TREE_LIST)
6870         vt = TREE_VALUE (vt);
6871       if (TREE_CODE (vt) == TREE_VEC)
6872         binfo = vt;
6873       else
6874         break;
6875     }
6876
6877   return vt;
6878 }
6879
6880 /* Recursively build the VTT-initializer for BINFO (which is in the
6881    hierarchy dominated by T).  INITS points to the end of the initializer
6882    list to date.  INDEX is the VTT index where the next element will be
6883    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6884    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
6885    for virtual bases of T. When it is not so, we build the constructor
6886    vtables for the BINFO-in-T variant.  */
6887
6888 static tree *
6889 build_vtt_inits (tree binfo, tree t, tree* inits, tree* index)
6890 {
6891   int i;
6892   tree b;
6893   tree init;
6894   tree secondary_vptrs;
6895   int top_level_p = same_type_p (TREE_TYPE (binfo), t);
6896
6897   /* We only need VTTs for subobjects with virtual bases.  */
6898   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
6899     return inits;
6900
6901   /* We need to use a construction vtable if this is not the primary
6902      VTT.  */
6903   if (!top_level_p)
6904     {
6905       build_ctor_vtbl_group (binfo, t);
6906
6907       /* Record the offset in the VTT where this sub-VTT can be found.  */
6908       BINFO_SUBVTT_INDEX (binfo) = *index;
6909     }
6910
6911   /* Add the address of the primary vtable for the complete object.  */
6912   init = binfo_ctor_vtable (binfo);
6913   *inits = build_tree_list (NULL_TREE, init);
6914   inits = &TREE_CHAIN (*inits);
6915   if (top_level_p)
6916     {
6917       my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129);
6918       BINFO_VPTR_INDEX (binfo) = *index;
6919     }
6920   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
6921
6922   /* Recursively add the secondary VTTs for non-virtual bases.  */
6923   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
6924     {
6925       b = BINFO_BASETYPE (binfo, i);
6926       if (!TREE_VIA_VIRTUAL (b))
6927         inits = build_vtt_inits (BINFO_BASETYPE (binfo, i), t,
6928                                  inits, index);
6929     }
6930
6931   /* Add secondary virtual pointers for all subobjects of BINFO with
6932      either virtual bases or reachable along a virtual path, except
6933      subobjects that are non-virtual primary bases.  */
6934   secondary_vptrs = tree_cons (t, NULL_TREE, BINFO_TYPE (binfo));
6935   TREE_TYPE (secondary_vptrs) = *index;
6936   VTT_TOP_LEVEL_P (secondary_vptrs) = top_level_p;
6937   VTT_MARKED_BINFO_P (secondary_vptrs) = 0;
6938
6939   dfs_walk_real (binfo,
6940                  dfs_build_secondary_vptr_vtt_inits,
6941                  NULL,
6942                  dfs_ctor_vtable_bases_queue_p,
6943                  secondary_vptrs);
6944   VTT_MARKED_BINFO_P (secondary_vptrs) = 1;
6945   dfs_walk (binfo, dfs_unmark, dfs_ctor_vtable_bases_queue_p,
6946             secondary_vptrs);
6947
6948   *index = TREE_TYPE (secondary_vptrs);
6949
6950   /* The secondary vptrs come back in reverse order.  After we reverse
6951      them, and add the INITS, the last init will be the first element
6952      of the chain.  */
6953   secondary_vptrs = TREE_VALUE (secondary_vptrs);
6954   if (secondary_vptrs)
6955     {
6956       *inits = nreverse (secondary_vptrs);
6957       inits = &TREE_CHAIN (secondary_vptrs);
6958       my_friendly_assert (*inits == NULL_TREE, 20000517);
6959     }
6960
6961   /* Add the secondary VTTs for virtual bases.  */
6962   if (top_level_p)
6963     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
6964       {
6965         if (!TREE_VIA_VIRTUAL (b))
6966           continue;
6967
6968         inits = build_vtt_inits (b, t, inits, index);
6969       }
6970
6971   if (!top_level_p)
6972     {
6973       tree data = tree_cons (t, binfo, NULL_TREE);
6974       VTT_TOP_LEVEL_P (data) = 0;
6975       VTT_MARKED_BINFO_P (data) = 0;
6976
6977       dfs_walk (binfo, dfs_fixup_binfo_vtbls,
6978                 dfs_ctor_vtable_bases_queue_p,
6979                 data);
6980     }
6981
6982   return inits;
6983 }
6984
6985 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo
6986    for the base in most derived. DATA is a TREE_LIST who's
6987    TREE_CHAIN is the type of the base being
6988    constructed whilst this secondary vptr is live.  The TREE_UNSIGNED
6989    flag of DATA indicates that this is a constructor vtable.  The
6990    TREE_TOP_LEVEL flag indicates that this is the primary VTT.  */
6991
6992 static tree
6993 dfs_build_secondary_vptr_vtt_inits (tree binfo, void* data)
6994 {
6995   tree l;
6996   tree t;
6997   tree init;
6998   tree index;
6999   int top_level_p;
7000
7001   l = (tree) data;
7002   t = TREE_CHAIN (l);
7003   top_level_p = VTT_TOP_LEVEL_P (l);
7004
7005   BINFO_MARKED (binfo) = 1;
7006
7007   /* We don't care about bases that don't have vtables.  */
7008   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7009     return NULL_TREE;
7010
7011   /* We're only interested in proper subobjects of T.  */
7012   if (same_type_p (BINFO_TYPE (binfo), t))
7013     return NULL_TREE;
7014
7015   /* We're not interested in non-virtual primary bases.  */
7016   if (!TREE_VIA_VIRTUAL (binfo) && BINFO_PRIMARY_P (binfo))
7017     return NULL_TREE;
7018
7019   /* If BINFO has virtual bases or is reachable via a virtual path
7020      from T, it'll have a secondary vptr.  */
7021   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))
7022       && !binfo_via_virtual (binfo, t))
7023     return NULL_TREE;
7024
7025   /* Record the index where this secondary vptr can be found.  */
7026   index = TREE_TYPE (l);
7027   if (top_level_p)
7028     {
7029       my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129);
7030       BINFO_VPTR_INDEX (binfo) = index;
7031     }
7032   TREE_TYPE (l) = size_binop (PLUS_EXPR, index,
7033                               TYPE_SIZE_UNIT (ptr_type_node));
7034
7035   /* Add the initializer for the secondary vptr itself.  */
7036   if (top_level_p && TREE_VIA_VIRTUAL (binfo))
7037     {
7038       /* It's a primary virtual base, and this is not the construction
7039          vtable. Find the base this is primary of in the inheritance graph,
7040          and use that base's vtable now.  */
7041       while (BINFO_PRIMARY_BASE_OF (binfo))
7042         binfo = BINFO_PRIMARY_BASE_OF (binfo);
7043     }
7044   init = binfo_ctor_vtable (binfo);
7045   TREE_VALUE (l) = tree_cons (NULL_TREE, init, TREE_VALUE (l));
7046
7047   return NULL_TREE;
7048 }
7049
7050 /* dfs_walk_real predicate for building vtables. DATA is a TREE_LIST,
7051    VTT_MARKED_BINFO_P indicates whether marked or unmarked bases
7052    should be walked.  TREE_PURPOSE is the TREE_TYPE that dominates the
7053    hierarchy.  */
7054
7055 static tree
7056 dfs_ctor_vtable_bases_queue_p (tree derived, int ix,
7057                                void* data)
7058 {
7059   tree binfo = BINFO_BASETYPE (derived, ix);
7060
7061   if (!BINFO_MARKED (binfo) == VTT_MARKED_BINFO_P ((tree) data))
7062     return NULL_TREE;
7063   return binfo;
7064 }
7065
7066 /* Called from build_vtt_inits via dfs_walk. After building constructor
7067    vtables and generating the sub-vtt from them, we need to restore the
7068    BINFO_VTABLES that were scribbled on.  DATA is a TREE_LIST whose
7069    TREE_VALUE is the TREE_TYPE of the base whose sub vtt was generated.  */
7070
7071 static tree
7072 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7073 {
7074   BINFO_MARKED (binfo) = 0;
7075
7076   /* We don't care about bases that don't have vtables.  */
7077   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7078     return NULL_TREE;
7079
7080   /* If we scribbled the construction vtable vptr into BINFO, clear it
7081      out now.  */
7082   if (BINFO_VTABLE (binfo)
7083       && TREE_CODE (BINFO_VTABLE (binfo)) == TREE_LIST
7084       && (TREE_PURPOSE (BINFO_VTABLE (binfo))
7085           == TREE_VALUE ((tree) data)))
7086     BINFO_VTABLE (binfo) = TREE_CHAIN (BINFO_VTABLE (binfo));
7087
7088   return NULL_TREE;
7089 }
7090
7091 /* Build the construction vtable group for BINFO which is in the
7092    hierarchy dominated by T.  */
7093
7094 static void
7095 build_ctor_vtbl_group (tree binfo, tree t)
7096 {
7097   tree list;
7098   tree type;
7099   tree vtbl;
7100   tree inits;
7101   tree id;
7102   tree vbase;
7103
7104   /* See if we've already created this construction vtable group.  */
7105   id = mangle_ctor_vtbl_for_type (t, binfo);
7106   if (IDENTIFIER_GLOBAL_VALUE (id))
7107     return;
7108
7109   my_friendly_assert (!same_type_p (BINFO_TYPE (binfo), t), 20010124);
7110   /* Build a version of VTBL (with the wrong type) for use in
7111      constructing the addresses of secondary vtables in the
7112      construction vtable group.  */
7113   vtbl = build_vtable (t, id, ptr_type_node);
7114   list = build_tree_list (vtbl, NULL_TREE);
7115   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7116                          binfo, t, list);
7117
7118   /* Add the vtables for each of our virtual bases using the vbase in T
7119      binfo.  */
7120   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7121        vbase;
7122        vbase = TREE_CHAIN (vbase))
7123     {
7124       tree b;
7125
7126       if (!TREE_VIA_VIRTUAL (vbase))
7127         continue;
7128       b = copied_binfo (vbase, binfo);
7129
7130       accumulate_vtbl_inits (b, vbase, binfo, t, list);
7131     }
7132   inits = TREE_VALUE (list);
7133
7134   /* Figure out the type of the construction vtable.  */
7135   type = build_index_type (size_int (list_length (inits) - 1));
7136   type = build_cplus_array_type (vtable_entry_type, type);
7137   TREE_TYPE (vtbl) = type;
7138
7139   /* Initialize the construction vtable.  */
7140   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7141   initialize_array (vtbl, inits);
7142   dump_vtable (t, binfo, vtbl);
7143 }
7144
7145 /* Add the vtbl initializers for BINFO (and its bases other than
7146    non-virtual primaries) to the list of INITS.  BINFO is in the
7147    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
7148    the constructor the vtbl inits should be accumulated for. (If this
7149    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7150    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7151    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7152    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7153    but are not necessarily the same in terms of layout.  */
7154
7155 static void
7156 accumulate_vtbl_inits (tree binfo,
7157                        tree orig_binfo,
7158                        tree rtti_binfo,
7159                        tree t,
7160                        tree inits)
7161 {
7162   int i;
7163   int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7164
7165   my_friendly_assert (same_type_p (BINFO_TYPE (binfo),
7166                                    BINFO_TYPE (orig_binfo)),
7167                       20000517);
7168
7169   /* If it doesn't have a vptr, we don't do anything.  */
7170   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7171     return;
7172
7173   /* If we're building a construction vtable, we're not interested in
7174      subobjects that don't require construction vtables.  */
7175   if (ctor_vtbl_p
7176       && !TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))
7177       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7178     return;
7179
7180   /* Build the initializers for the BINFO-in-T vtable.  */
7181   TREE_VALUE (inits)
7182     = chainon (TREE_VALUE (inits),
7183                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7184                                           rtti_binfo, t, inits));
7185
7186   /* Walk the BINFO and its bases.  We walk in preorder so that as we
7187      initialize each vtable we can figure out at what offset the
7188      secondary vtable lies from the primary vtable.  We can't use
7189      dfs_walk here because we need to iterate through bases of BINFO
7190      and RTTI_BINFO simultaneously.  */
7191   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
7192     {
7193       tree base_binfo = BINFO_BASETYPE (binfo, i);
7194
7195       /* Skip virtual bases.  */
7196       if (TREE_VIA_VIRTUAL (base_binfo))
7197         continue;
7198       accumulate_vtbl_inits (base_binfo,
7199                              BINFO_BASETYPE (orig_binfo, i),
7200                              rtti_binfo, t,
7201                              inits);
7202     }
7203 }
7204
7205 /* Called from accumulate_vtbl_inits.  Returns the initializers for
7206    the BINFO vtable.  */
7207
7208 static tree
7209 dfs_accumulate_vtbl_inits (tree binfo,
7210                            tree orig_binfo,
7211                            tree rtti_binfo,
7212                            tree t,
7213                            tree l)
7214 {
7215   tree inits = NULL_TREE;
7216   tree vtbl = NULL_TREE;
7217   int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7218
7219   if (ctor_vtbl_p
7220       && TREE_VIA_VIRTUAL (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7221     {
7222       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7223          primary virtual base.  If it is not the same primary in
7224          the hierarchy of T, we'll need to generate a ctor vtable
7225          for it, to place at its location in T.  If it is the same
7226          primary, we still need a VTT entry for the vtable, but it
7227          should point to the ctor vtable for the base it is a
7228          primary for within the sub-hierarchy of RTTI_BINFO.
7229
7230          There are three possible cases:
7231
7232          1) We are in the same place.
7233          2) We are a primary base within a lost primary virtual base of
7234          RTTI_BINFO.
7235          3) We are primary to something not a base of RTTI_BINFO.  */
7236
7237       tree b = BINFO_PRIMARY_BASE_OF (binfo);
7238       tree last = NULL_TREE;
7239
7240       /* First, look through the bases we are primary to for RTTI_BINFO
7241          or a virtual base.  */
7242       for (; b; b = BINFO_PRIMARY_BASE_OF (b))
7243         {
7244           last = b;
7245           if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo)
7246             break;
7247         }
7248       /* If we run out of primary links, keep looking down our
7249          inheritance chain; we might be an indirect primary.  */
7250       if (b == NULL_TREE)
7251         for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7252           if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo)
7253             break;
7254
7255       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7256          base B and it is a base of RTTI_BINFO, this is case 2.  In
7257          either case, we share our vtable with LAST, i.e. the
7258          derived-most base within B of which we are a primary.  */
7259       if (b == rtti_binfo
7260           || (b && purpose_member (BINFO_TYPE (b),
7261                                    CLASSTYPE_VBASECLASSES (BINFO_TYPE (rtti_binfo)))))
7262         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7263            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7264            binfo_ctor_vtable after everything's been set up.  */
7265         vtbl = last;
7266
7267       /* Otherwise, this is case 3 and we get our own.  */
7268     }
7269   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7270     return inits;
7271
7272   if (!vtbl)
7273     {
7274       tree index;
7275       int non_fn_entries;
7276
7277       /* Compute the initializer for this vtable.  */
7278       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7279                                       &non_fn_entries);
7280
7281       /* Figure out the position to which the VPTR should point.  */
7282       vtbl = TREE_PURPOSE (l);
7283       vtbl = build1 (ADDR_EXPR,
7284                      vtbl_ptr_type_node,
7285                      vtbl);
7286       TREE_CONSTANT (vtbl) = 1;
7287       index = size_binop (PLUS_EXPR,
7288                           size_int (non_fn_entries),
7289                           size_int (list_length (TREE_VALUE (l))));
7290       index = size_binop (MULT_EXPR,
7291                           TYPE_SIZE_UNIT (vtable_entry_type),
7292                           index);
7293       vtbl = build (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7294       TREE_CONSTANT (vtbl) = 1;
7295     }
7296
7297   if (ctor_vtbl_p)
7298     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7299        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7300        straighten this out.  */
7301     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7302   else if (BINFO_PRIMARY_P (binfo) && TREE_VIA_VIRTUAL (binfo))
7303     inits = NULL_TREE;
7304   else
7305      /* For an ordinary vtable, set BINFO_VTABLE.  */
7306     BINFO_VTABLE (binfo) = vtbl;
7307
7308   return inits;
7309 }
7310
7311 /* Construct the initializer for BINFO's virtual function table.  BINFO
7312    is part of the hierarchy dominated by T.  If we're building a
7313    construction vtable, the ORIG_BINFO is the binfo we should use to
7314    find the actual function pointers to put in the vtable - but they
7315    can be overridden on the path to most-derived in the graph that
7316    ORIG_BINFO belongs.  Otherwise,
7317    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7318    BINFO that should be indicated by the RTTI information in the
7319    vtable; it will be a base class of T, rather than T itself, if we
7320    are building a construction vtable.
7321
7322    The value returned is a TREE_LIST suitable for wrapping in a
7323    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7324    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7325    number of non-function entries in the vtable.
7326
7327    It might seem that this function should never be called with a
7328    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7329    base is always subsumed by a derived class vtable.  However, when
7330    we are building construction vtables, we do build vtables for
7331    primary bases; we need these while the primary base is being
7332    constructed.  */
7333
7334 static tree
7335 build_vtbl_initializer (tree binfo,
7336                         tree orig_binfo,
7337                         tree t,
7338                         tree rtti_binfo,
7339                         int* non_fn_entries_p)
7340 {
7341   tree v, b;
7342   tree vfun_inits;
7343   tree vbase;
7344   vtbl_init_data vid;
7345
7346   /* Initialize VID.  */
7347   memset (&vid, 0, sizeof (vid));
7348   vid.binfo = binfo;
7349   vid.derived = t;
7350   vid.rtti_binfo = rtti_binfo;
7351   vid.last_init = &vid.inits;
7352   vid.primary_vtbl_p = (binfo == TYPE_BINFO (t));
7353   vid.ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7354   vid.generate_vcall_entries = true;
7355   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7356   vid.index = ssize_int (-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7357
7358   /* Add entries to the vtable for RTTI.  */
7359   build_rtti_vtbl_entries (binfo, &vid);
7360
7361   /* Create an array for keeping track of the functions we've
7362      processed.  When we see multiple functions with the same
7363      signature, we share the vcall offsets.  */
7364   VARRAY_TREE_INIT (vid.fns, 32, "fns");
7365   /* Add the vcall and vbase offset entries.  */
7366   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7367   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7368      build_vbase_offset_vtbl_entries.  */
7369   for (vbase = CLASSTYPE_VBASECLASSES (t);
7370        vbase;
7371        vbase = TREE_CHAIN (vbase))
7372     BINFO_VTABLE_PATH_MARKED (TREE_VALUE (vbase)) = 0;
7373
7374   /* If the target requires padding between data entries, add that now.  */
7375   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7376     {
7377       tree cur, *prev;
7378
7379       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7380         {
7381           tree add = cur;
7382           int i;
7383
7384           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7385             add = tree_cons (NULL_TREE,
7386                              build1 (NOP_EXPR, vtable_entry_type,
7387                                      null_pointer_node),
7388                              add);
7389           *prev = add;
7390         }
7391     }
7392
7393   if (non_fn_entries_p)
7394     *non_fn_entries_p = list_length (vid.inits);
7395
7396   /* Go through all the ordinary virtual functions, building up
7397      initializers.  */
7398   vfun_inits = NULL_TREE;
7399   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7400     {
7401       tree delta;
7402       tree vcall_index;
7403       tree fn, fn_original;
7404       tree init = NULL_TREE;
7405
7406       fn = BV_FN (v);
7407       fn_original = fn;
7408       if (DECL_THUNK_P (fn))
7409         {
7410           if (!DECL_NAME (fn))
7411             finish_thunk (fn);
7412           if (THUNK_ALIAS (fn))
7413             {
7414               fn = THUNK_ALIAS (fn);
7415               BV_FN (v) = fn;
7416             }
7417           fn_original = THUNK_TARGET (fn);
7418         }
7419
7420       /* If the only definition of this function signature along our
7421          primary base chain is from a lost primary, this vtable slot will
7422          never be used, so just zero it out.  This is important to avoid
7423          requiring extra thunks which cannot be generated with the function.
7424
7425          We first check this in update_vtable_entry_for_fn, so we handle
7426          restored primary bases properly; we also need to do it here so we
7427          zero out unused slots in ctor vtables, rather than filling themff
7428          with erroneous values (though harmless, apart from relocation
7429          costs).  */
7430       for (b = binfo; ; b = get_primary_binfo (b))
7431         {
7432           /* We found a defn before a lost primary; go ahead as normal.  */
7433           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7434             break;
7435
7436           /* The nearest definition is from a lost primary; clear the
7437              slot.  */
7438           if (BINFO_LOST_PRIMARY_P (b))
7439             {
7440               init = size_zero_node;
7441               break;
7442             }
7443         }
7444
7445       if (! init)
7446         {
7447           /* Pull the offset for `this', and the function to call, out of
7448              the list.  */
7449           delta = BV_DELTA (v);
7450           vcall_index = BV_VCALL_INDEX (v);
7451
7452           my_friendly_assert (TREE_CODE (delta) == INTEGER_CST, 19990727);
7453           my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 19990727);
7454
7455           /* You can't call an abstract virtual function; it's abstract.
7456              So, we replace these functions with __pure_virtual.  */
7457           if (DECL_PURE_VIRTUAL_P (fn_original))
7458             fn = abort_fndecl;
7459           else if (!integer_zerop (delta) || vcall_index)
7460             {
7461               fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7462               if (!DECL_NAME (fn))
7463                 finish_thunk (fn);
7464             }
7465           /* Take the address of the function, considering it to be of an
7466              appropriate generic type.  */
7467           init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7468           /* The address of a function can't change.  */
7469           TREE_CONSTANT (init) = 1;
7470         }
7471
7472       /* And add it to the chain of initializers.  */
7473       if (TARGET_VTABLE_USES_DESCRIPTORS)
7474         {
7475           int i;
7476           if (init == size_zero_node)
7477             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7478               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7479           else
7480             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7481               {
7482                 tree fdesc = build (FDESC_EXPR, vfunc_ptr_type_node,
7483                                     TREE_OPERAND (init, 0),
7484                                     build_int_2 (i, 0));
7485                 TREE_CONSTANT (fdesc) = 1;
7486
7487                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7488               }
7489         }
7490       else
7491         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7492     }
7493
7494   /* The initializers for virtual functions were built up in reverse
7495      order; straighten them out now.  */
7496   vfun_inits = nreverse (vfun_inits);
7497
7498   /* The negative offset initializers are also in reverse order.  */
7499   vid.inits = nreverse (vid.inits);
7500
7501   /* Chain the two together.  */
7502   return chainon (vid.inits, vfun_inits);
7503 }
7504
7505 /* Adds to vid->inits the initializers for the vbase and vcall
7506    offsets in BINFO, which is in the hierarchy dominated by T.  */
7507
7508 static void
7509 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7510 {
7511   tree b;
7512
7513   /* If this is a derived class, we must first create entries
7514      corresponding to the primary base class.  */
7515   b = get_primary_binfo (binfo);
7516   if (b)
7517     build_vcall_and_vbase_vtbl_entries (b, vid);
7518
7519   /* Add the vbase entries for this base.  */
7520   build_vbase_offset_vtbl_entries (binfo, vid);
7521   /* Add the vcall entries for this base.  */
7522   build_vcall_offset_vtbl_entries (binfo, vid);
7523 }
7524
7525 /* Returns the initializers for the vbase offset entries in the vtable
7526    for BINFO (which is part of the class hierarchy dominated by T), in
7527    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7528    where the next vbase offset will go.  */
7529
7530 static void
7531 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7532 {
7533   tree vbase;
7534   tree t;
7535   tree non_primary_binfo;
7536
7537   /* If there are no virtual baseclasses, then there is nothing to
7538      do.  */
7539   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
7540     return;
7541
7542   t = vid->derived;
7543
7544   /* We might be a primary base class.  Go up the inheritance hierarchy
7545      until we find the most derived class of which we are a primary base:
7546      it is the offset of that which we need to use.  */
7547   non_primary_binfo = binfo;
7548   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7549     {
7550       tree b;
7551
7552       /* If we have reached a virtual base, then it must be a primary
7553          base (possibly multi-level) of vid->binfo, or we wouldn't
7554          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7555          might be a lost primary, so just skip down to vid->binfo.  */
7556       if (TREE_VIA_VIRTUAL (non_primary_binfo))
7557         {
7558           non_primary_binfo = vid->binfo;
7559           break;
7560         }
7561
7562       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7563       if (get_primary_binfo (b) != non_primary_binfo)
7564         break;
7565       non_primary_binfo = b;
7566     }
7567
7568   /* Go through the virtual bases, adding the offsets.  */
7569   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7570        vbase;
7571        vbase = TREE_CHAIN (vbase))
7572     {
7573       tree b;
7574       tree delta;
7575
7576       if (!TREE_VIA_VIRTUAL (vbase))
7577         continue;
7578
7579       /* Find the instance of this virtual base in the complete
7580          object.  */
7581       b = copied_binfo (vbase, binfo);
7582
7583       /* If we've already got an offset for this virtual base, we
7584          don't need another one.  */
7585       if (BINFO_VTABLE_PATH_MARKED (b))
7586         continue;
7587       BINFO_VTABLE_PATH_MARKED (b) = 1;
7588
7589       /* Figure out where we can find this vbase offset.  */
7590       delta = size_binop (MULT_EXPR,
7591                           vid->index,
7592                           convert (ssizetype,
7593                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7594       if (vid->primary_vtbl_p)
7595         BINFO_VPTR_FIELD (b) = delta;
7596
7597       if (binfo != TYPE_BINFO (t))
7598         {
7599           /* The vbase offset had better be the same.  */
7600           my_friendly_assert (tree_int_cst_equal (delta,
7601                                                   BINFO_VPTR_FIELD (vbase)),
7602                               20030202);
7603         }
7604
7605       /* The next vbase will come at a more negative offset.  */
7606       vid->index = size_binop (MINUS_EXPR, vid->index,
7607                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7608
7609       /* The initializer is the delta from BINFO to this virtual base.
7610          The vbase offsets go in reverse inheritance-graph order, and
7611          we are walking in inheritance graph order so these end up in
7612          the right order.  */
7613       delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7614
7615       *vid->last_init
7616         = build_tree_list (NULL_TREE,
7617                            fold (build1 (NOP_EXPR,
7618                                          vtable_entry_type,
7619                                          delta)));
7620       vid->last_init = &TREE_CHAIN (*vid->last_init);
7621     }
7622 }
7623
7624 /* Adds the initializers for the vcall offset entries in the vtable
7625    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7626    to VID->INITS.  */
7627
7628 static void
7629 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7630 {
7631   /* We only need these entries if this base is a virtual base.  We
7632      compute the indices -- but do not add to the vtable -- when
7633      building the main vtable for a class.  */
7634   if (TREE_VIA_VIRTUAL (binfo) || binfo == TYPE_BINFO (vid->derived))
7635     {
7636       /* We need a vcall offset for each of the virtual functions in this
7637          vtable.  For example:
7638
7639            class A { virtual void f (); };
7640            class B1 : virtual public A { virtual void f (); };
7641            class B2 : virtual public A { virtual void f (); };
7642            class C: public B1, public B2 { virtual void f (); };
7643
7644          A C object has a primary base of B1, which has a primary base of A.  A
7645          C also has a secondary base of B2, which no longer has a primary base
7646          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7647          A, which will adjust the A* to a B2* to call f.  We have no way of
7648          knowing what (or even whether) this offset will be when we define B2,
7649          so we store this "vcall offset" in the A sub-vtable and look it up in
7650          a "virtual thunk" for B2::f.
7651
7652          We need entries for all the functions in our primary vtable and
7653          in our non-virtual bases' secondary vtables.  */
7654       vid->vbase = binfo;
7655       /* If we are just computing the vcall indices -- but do not need
7656          the actual entries -- not that.  */
7657       if (!TREE_VIA_VIRTUAL (binfo))
7658         vid->generate_vcall_entries = false;
7659       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7660       add_vcall_offset_vtbl_entries_r (binfo, vid);
7661     }
7662 }
7663
7664 /* Build vcall offsets, starting with those for BINFO.  */
7665
7666 static void
7667 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7668 {
7669   int i;
7670   tree primary_binfo;
7671
7672   /* Don't walk into virtual bases -- except, of course, for the
7673      virtual base for which we are building vcall offsets.  Any
7674      primary virtual base will have already had its offsets generated
7675      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7676   if (TREE_VIA_VIRTUAL (binfo) && vid->vbase != binfo)
7677     return;
7678
7679   /* If BINFO has a primary base, process it first.  */
7680   primary_binfo = get_primary_binfo (binfo);
7681   if (primary_binfo)
7682     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7683
7684   /* Add BINFO itself to the list.  */
7685   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7686
7687   /* Scan the non-primary bases of BINFO.  */
7688   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
7689     {
7690       tree base_binfo;
7691
7692       base_binfo = BINFO_BASETYPE (binfo, i);
7693       if (base_binfo != primary_binfo)
7694         add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7695     }
7696 }
7697
7698 /* Called from build_vcall_offset_vtbl_entries_r.  */
7699
7700 static void
7701 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7702 {
7703   /* Make entries for the rest of the virtuals.  */
7704   if (abi_version_at_least (2))
7705     {
7706       tree orig_fn;
7707
7708       /* The ABI requires that the methods be processed in declaration
7709          order.  G++ 3.2 used the order in the vtable.  */
7710       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7711            orig_fn;
7712            orig_fn = TREE_CHAIN (orig_fn))
7713         if (DECL_VINDEX (orig_fn))
7714           add_vcall_offset (orig_fn, binfo, vid);
7715     }
7716   else
7717     {
7718       tree derived_virtuals;
7719       tree base_virtuals;
7720       tree orig_virtuals;
7721       /* If BINFO is a primary base, the most derived class which has
7722          BINFO as a primary base; otherwise, just BINFO.  */
7723       tree non_primary_binfo;
7724
7725       /* We might be a primary base class.  Go up the inheritance hierarchy
7726          until we find the most derived class of which we are a primary base:
7727          it is the BINFO_VIRTUALS there that we need to consider.  */
7728       non_primary_binfo = binfo;
7729       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7730         {
7731           tree b;
7732
7733           /* If we have reached a virtual base, then it must be vid->vbase,
7734              because we ignore other virtual bases in
7735              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7736              base (possibly multi-level) of vid->binfo, or we wouldn't
7737              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7738              might be a lost primary, so just skip down to vid->binfo.  */
7739           if (TREE_VIA_VIRTUAL (non_primary_binfo))
7740             {
7741               if (non_primary_binfo != vid->vbase)
7742                 abort ();
7743               non_primary_binfo = vid->binfo;
7744               break;
7745             }
7746
7747           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7748           if (get_primary_binfo (b) != non_primary_binfo)
7749             break;
7750           non_primary_binfo = b;
7751         }
7752
7753       if (vid->ctor_vtbl_p)
7754         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7755            where rtti_binfo is the most derived type.  */
7756         non_primary_binfo
7757           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7758
7759       for (base_virtuals = BINFO_VIRTUALS (binfo),
7760              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7761              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7762            base_virtuals;
7763            base_virtuals = TREE_CHAIN (base_virtuals),
7764              derived_virtuals = TREE_CHAIN (derived_virtuals),
7765              orig_virtuals = TREE_CHAIN (orig_virtuals))
7766         {
7767           tree orig_fn;
7768
7769           /* Find the declaration that originally caused this function to
7770              be present in BINFO_TYPE (binfo).  */
7771           orig_fn = BV_FN (orig_virtuals);
7772
7773           /* When processing BINFO, we only want to generate vcall slots for
7774              function slots introduced in BINFO.  So don't try to generate
7775              one if the function isn't even defined in BINFO.  */
7776           if (!same_type_p (DECL_CONTEXT (orig_fn), BINFO_TYPE (binfo)))
7777             continue;
7778
7779           add_vcall_offset (orig_fn, binfo, vid);
7780         }
7781     }
7782 }
7783
7784 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7785
7786 static void
7787 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7788 {
7789   size_t i;
7790   tree vcall_offset;
7791
7792   /* If there is already an entry for a function with the same
7793      signature as FN, then we do not need a second vcall offset.
7794      Check the list of functions already present in the derived
7795      class vtable.  */
7796   for (i = 0; i < VARRAY_ACTIVE_SIZE (vid->fns); ++i)
7797     {
7798       tree derived_entry;
7799
7800       derived_entry = VARRAY_TREE (vid->fns, i);
7801       if (same_signature_p (derived_entry, orig_fn)
7802           /* We only use one vcall offset for virtual destructors,
7803              even though there are two virtual table entries.  */
7804           || (DECL_DESTRUCTOR_P (derived_entry)
7805               && DECL_DESTRUCTOR_P (orig_fn)))
7806         return;
7807     }
7808
7809   /* If we are building these vcall offsets as part of building
7810      the vtable for the most derived class, remember the vcall
7811      offset.  */
7812   if (vid->binfo == TYPE_BINFO (vid->derived))
7813     CLASSTYPE_VCALL_INDICES (vid->derived)
7814       = tree_cons (orig_fn, vid->index,
7815                    CLASSTYPE_VCALL_INDICES (vid->derived));
7816
7817   /* The next vcall offset will be found at a more negative
7818      offset.  */
7819   vid->index = size_binop (MINUS_EXPR, vid->index,
7820                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7821
7822   /* Keep track of this function.  */
7823   VARRAY_PUSH_TREE (vid->fns, orig_fn);
7824
7825   if (vid->generate_vcall_entries)
7826     {
7827       tree base;
7828       tree fn;
7829
7830       /* Find the overriding function.  */
7831       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7832       if (fn == error_mark_node)
7833         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7834                                integer_zero_node);
7835       else
7836         {
7837           base = TREE_VALUE (fn);
7838
7839           /* The vbase we're working on is a primary base of
7840              vid->binfo.  But it might be a lost primary, so its
7841              BINFO_OFFSET might be wrong, so we just use the
7842              BINFO_OFFSET from vid->binfo.  */
7843           vcall_offset = size_diffop (BINFO_OFFSET (base),
7844                                       BINFO_OFFSET (vid->binfo));
7845           vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type,
7846                                        vcall_offset));
7847         }
7848       /* Add the initializer to the vtable.  */
7849       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7850       vid->last_init = &TREE_CHAIN (*vid->last_init);
7851     }
7852 }
7853
7854 /* Return vtbl initializers for the RTTI entries corresponding to the
7855    BINFO's vtable.  The RTTI entries should indicate the object given
7856    by VID->rtti_binfo.  */
7857
7858 static void
7859 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7860 {
7861   tree b;
7862   tree t;
7863   tree basetype;
7864   tree offset;
7865   tree decl;
7866   tree init;
7867
7868   basetype = BINFO_TYPE (binfo);
7869   t = BINFO_TYPE (vid->rtti_binfo);
7870
7871   /* To find the complete object, we will first convert to our most
7872      primary base, and then add the offset in the vtbl to that value.  */
7873   b = binfo;
7874   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7875          && !BINFO_LOST_PRIMARY_P (b))
7876     {
7877       tree primary_base;
7878
7879       primary_base = get_primary_binfo (b);
7880       my_friendly_assert (BINFO_PRIMARY_BASE_OF (primary_base) == b, 20010127);
7881       b = primary_base;
7882     }
7883   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7884
7885   /* The second entry is the address of the typeinfo object.  */
7886   if (flag_rtti)
7887     decl = build_address (get_tinfo_decl (t));
7888   else
7889     decl = integer_zero_node;
7890
7891   /* Convert the declaration to a type that can be stored in the
7892      vtable.  */
7893   init = build_nop (vfunc_ptr_type_node, decl);
7894   *vid->last_init = build_tree_list (NULL_TREE, init);
7895   vid->last_init = &TREE_CHAIN (*vid->last_init);
7896
7897   /* Add the offset-to-top entry.  It comes earlier in the vtable that
7898      the the typeinfo entry.  Convert the offset to look like a
7899      function pointer, so that we can put it in the vtable.  */
7900   init = build_nop (vfunc_ptr_type_node, offset);
7901   *vid->last_init = build_tree_list (NULL_TREE, init);
7902   vid->last_init = &TREE_CHAIN (*vid->last_init);
7903 }