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