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