gcc/cp/class.c

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