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