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