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       && !type_has_move_constructor (t))
2741     {
2742       TYPE_HAS_COPY_CTOR (t) = 1;
2743       TYPE_HAS_CONST_COPY_CTOR (t) = !cant_have_const_cctor;
2744       CLASSTYPE_LAZY_COPY_CTOR (t) = 1;
2745       if (cxx_dialect >= cxx0x)
2746         CLASSTYPE_LAZY_MOVE_CTOR (t) = 1;
2747     }
2748
2749   /* If there is no assignment operator, one will be created if and
2750      when it is needed.  For now, just record whether or not the type
2751      of the parameter to the assignment operator will be a const or
2752      non-const reference.  */
2753   if (!TYPE_HAS_COPY_ASSIGN (t) && !TYPE_FOR_JAVA (t)
2754       && !type_has_move_assign (t))
2755     {
2756       TYPE_HAS_COPY_ASSIGN (t) = 1;
2757       TYPE_HAS_CONST_COPY_ASSIGN (t) = !cant_have_const_assignment;
2758       CLASSTYPE_LAZY_COPY_ASSIGN (t) = 1;
2759       if (cxx_dialect >= cxx0x)
2760         CLASSTYPE_LAZY_MOVE_ASSIGN (t) = 1;
2761     }
2762
2763   /* We can't be lazy about declaring functions that might override
2764      a virtual function from a base class.  */
2765   declare_virt_assop_and_dtor (t);
2766 }
2767
2768 /* Subroutine of finish_struct_1.  Recursively count the number of fields
2769    in TYPE, including anonymous union members.  */
2770
2771 static int
2772 count_fields (tree fields)
2773 {
2774   tree x;
2775   int n_fields = 0;
2776   for (x = fields; x; x = DECL_CHAIN (x))
2777     {
2778       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2779         n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
2780       else
2781         n_fields += 1;
2782     }
2783   return n_fields;
2784 }
2785
2786 /* Subroutine of finish_struct_1.  Recursively add all the fields in the
2787    TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX.  */
2788
2789 static int
2790 add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx)
2791 {
2792   tree x;
2793   for (x = fields; x; x = DECL_CHAIN (x))
2794     {
2795       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2796         idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
2797       else
2798         field_vec->elts[idx++] = x;
2799     }
2800   return idx;
2801 }
2802
2803 /* FIELD is a bit-field.  We are finishing the processing for its
2804    enclosing type.  Issue any appropriate messages and set appropriate
2805    flags.  Returns false if an error has been diagnosed.  */
2806
2807 static bool
2808 check_bitfield_decl (tree field)
2809 {
2810   tree type = TREE_TYPE (field);
2811   tree w;
2812
2813   /* Extract the declared width of the bitfield, which has been
2814      temporarily stashed in DECL_INITIAL.  */
2815   w = DECL_INITIAL (field);
2816   gcc_assert (w != NULL_TREE);
2817   /* Remove the bit-field width indicator so that the rest of the
2818      compiler does not treat that value as an initializer.  */
2819   DECL_INITIAL (field) = NULL_TREE;
2820
2821   /* Detect invalid bit-field type.  */
2822   if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
2823     {
2824       error ("bit-field %q+#D with non-integral type", field);
2825       w = error_mark_node;
2826     }
2827   else
2828     {
2829       location_t loc = input_location;
2830       /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs.  */
2831       STRIP_NOPS (w);
2832
2833       /* detect invalid field size.  */
2834       input_location = DECL_SOURCE_LOCATION (field);
2835       w = cxx_constant_value (w);
2836       input_location = loc;
2837
2838       if (TREE_CODE (w) != INTEGER_CST)
2839         {
2840           error ("bit-field %q+D width not an integer constant", field);
2841           w = error_mark_node;
2842         }
2843       else if (tree_int_cst_sgn (w) < 0)
2844         {
2845           error ("negative width in bit-field %q+D", field);
2846           w = error_mark_node;
2847         }
2848       else if (integer_zerop (w) && DECL_NAME (field) != 0)
2849         {
2850           error ("zero width for bit-field %q+D", field);
2851           w = error_mark_node;
2852         }
2853       else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2854                && TREE_CODE (type) != ENUMERAL_TYPE
2855                && TREE_CODE (type) != BOOLEAN_TYPE)
2856         warning (0, "width of %q+D exceeds its type", field);
2857       else if (TREE_CODE (type) == ENUMERAL_TYPE
2858                && (0 > (compare_tree_int
2859                         (w, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type))))))
2860         warning (0, "%q+D is too small to hold all values of %q#T", field, type);
2861     }
2862
2863   if (w != error_mark_node)
2864     {
2865       DECL_SIZE (field) = convert (bitsizetype, w);
2866       DECL_BIT_FIELD (field) = 1;
2867       return true;
2868     }
2869   else
2870     {
2871       /* Non-bit-fields are aligned for their type.  */
2872       DECL_BIT_FIELD (field) = 0;
2873       CLEAR_DECL_C_BIT_FIELD (field);
2874       return false;
2875     }
2876 }
2877
2878 /* FIELD is a non bit-field.  We are finishing the processing for its
2879    enclosing type T.  Issue any appropriate messages and set appropriate
2880    flags.  */
2881
2882 static void
2883 check_field_decl (tree field,
2884                   tree t,
2885                   int* cant_have_const_ctor,
2886                   int* no_const_asn_ref,
2887                   int* any_default_members)
2888 {
2889   tree type = strip_array_types (TREE_TYPE (field));
2890
2891   /* In C++98 an anonymous union cannot contain any fields which would change
2892      the settings of CANT_HAVE_CONST_CTOR and friends.  */
2893   if (ANON_UNION_TYPE_P (type) && cxx_dialect < cxx0x)
2894     ;
2895   /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous
2896      structs.  So, we recurse through their fields here.  */
2897   else if (ANON_AGGR_TYPE_P (type))
2898     {
2899       tree fields;
2900
2901       for (fields = TYPE_FIELDS (type); fields; fields = DECL_CHAIN (fields))
2902         if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2903           check_field_decl (fields, t, cant_have_const_ctor,
2904                             no_const_asn_ref, any_default_members);
2905     }
2906   /* Check members with class type for constructors, destructors,
2907      etc.  */
2908   else if (CLASS_TYPE_P (type))
2909     {
2910       /* Never let anything with uninheritable virtuals
2911          make it through without complaint.  */
2912       abstract_virtuals_error (field, type);
2913
2914       if (TREE_CODE (t) == UNION_TYPE && cxx_dialect < cxx0x)
2915         {
2916           static bool warned;
2917           int oldcount = errorcount;
2918           if (TYPE_NEEDS_CONSTRUCTING (type))
2919             error ("member %q+#D with constructor not allowed in union",
2920                    field);
2921           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2922             error ("member %q+#D with destructor not allowed in union", field);
2923           if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
2924             error ("member %q+#D with copy assignment operator not allowed in union",
2925                    field);
2926           if (!warned && errorcount > oldcount)
2927             {
2928               inform (DECL_SOURCE_LOCATION (field), "unrestricted unions "
2929                       "only available with -std=c++0x or -std=gnu++0x");
2930               warned = true;
2931             }
2932         }
2933       else
2934         {
2935           TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2936           TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2937             |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2938           TYPE_HAS_COMPLEX_COPY_ASSIGN (t)
2939             |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (type)
2940                 || !TYPE_HAS_COPY_ASSIGN (type));
2941           TYPE_HAS_COMPLEX_COPY_CTOR (t) |= (TYPE_HAS_COMPLEX_COPY_CTOR (type)
2942                                              || !TYPE_HAS_COPY_CTOR (type));
2943           TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (type);
2944           TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_HAS_COMPLEX_MOVE_CTOR (type);
2945           TYPE_HAS_COMPLEX_DFLT (t) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)
2946                                         || TYPE_HAS_COMPLEX_DFLT (type));
2947         }
2948
2949       if (TYPE_HAS_COPY_CTOR (type)
2950           && !TYPE_HAS_CONST_COPY_CTOR (type))
2951         *cant_have_const_ctor = 1;
2952
2953       if (TYPE_HAS_COPY_ASSIGN (type)
2954           && !TYPE_HAS_CONST_COPY_ASSIGN (type))
2955         *no_const_asn_ref = 1;
2956     }
2957   if (DECL_INITIAL (field) != NULL_TREE)
2958     {
2959       /* `build_class_init_list' does not recognize
2960          non-FIELD_DECLs.  */
2961       if (TREE_CODE (t) == UNION_TYPE && *any_default_members != 0)
2962         error ("multiple fields in union %qT initialized", t);
2963       *any_default_members = 1;
2964     }
2965 }
2966
2967 /* Check the data members (both static and non-static), class-scoped
2968    typedefs, etc., appearing in the declaration of T.  Issue
2969    appropriate diagnostics.  Sets ACCESS_DECLS to a list (in
2970    declaration order) of access declarations; each TREE_VALUE in this
2971    list is a USING_DECL.
2972
2973    In addition, set the following flags:
2974
2975      EMPTY_P
2976        The class is empty, i.e., contains no non-static data members.
2977
2978      CANT_HAVE_CONST_CTOR_P
2979        This class cannot have an implicitly generated copy constructor
2980        taking a const reference.
2981
2982      CANT_HAVE_CONST_ASN_REF
2983        This class cannot have an implicitly generated assignment
2984        operator taking a const reference.
2985
2986    All of these flags should be initialized before calling this
2987    function.
2988
2989    Returns a pointer to the end of the TYPE_FIELDs chain; additional
2990    fields can be added by adding to this chain.  */
2991
2992 static void
2993 check_field_decls (tree t, tree *access_decls,
2994                    int *cant_have_const_ctor_p,
2995                    int *no_const_asn_ref_p)
2996 {
2997   tree *field;
2998   tree *next;
2999   bool has_pointers;
3000   int any_default_members;
3001   int cant_pack = 0;
3002   int field_access = -1;
3003
3004   /* Assume there are no access declarations.  */
3005   *access_decls = NULL_TREE;
3006   /* Assume this class has no pointer members.  */
3007   has_pointers = false;
3008   /* Assume none of the members of this class have default
3009      initializations.  */
3010   any_default_members = 0;
3011
3012   for (field = &TYPE_FIELDS (t); *field; field = next)
3013     {
3014       tree x = *field;
3015       tree type = TREE_TYPE (x);
3016       int this_field_access;
3017
3018       next = &DECL_CHAIN (x);
3019
3020       if (TREE_CODE (x) == USING_DECL)
3021         {
3022           /* Prune the access declaration from the list of fields.  */
3023           *field = DECL_CHAIN (x);
3024
3025           /* Save the access declarations for our caller.  */
3026           *access_decls = tree_cons (NULL_TREE, x, *access_decls);
3027
3028           /* Since we've reset *FIELD there's no reason to skip to the
3029              next field.  */
3030           next = field;
3031           continue;
3032         }
3033
3034       if (TREE_CODE (x) == TYPE_DECL
3035           || TREE_CODE (x) == TEMPLATE_DECL)
3036         continue;
3037
3038       /* If we've gotten this far, it's a data member, possibly static,
3039          or an enumerator.  */
3040       DECL_CONTEXT (x) = t;
3041
3042       /* When this goes into scope, it will be a non-local reference.  */
3043       DECL_NONLOCAL (x) = 1;
3044
3045       if (TREE_CODE (t) == UNION_TYPE)
3046         {
3047           /* [class.union]
3048
3049              If a union contains a static data member, or a member of
3050              reference type, the program is ill-formed.  */
3051           if (TREE_CODE (x) == VAR_DECL)
3052             {
3053               error ("%q+D may not be static because it is a member of a union", x);
3054               continue;
3055             }
3056           if (TREE_CODE (type) == REFERENCE_TYPE)
3057             {
3058               error ("%q+D may not have reference type %qT because"
3059                      " it is a member of a union",
3060                      x, type);
3061               continue;
3062             }
3063         }
3064
3065       /* Perform error checking that did not get done in
3066          grokdeclarator.  */
3067       if (TREE_CODE (type) == FUNCTION_TYPE)
3068         {
3069           error ("field %q+D invalidly declared function type", x);
3070           type = build_pointer_type (type);
3071           TREE_TYPE (x) = type;
3072         }
3073       else if (TREE_CODE (type) == METHOD_TYPE)
3074         {
3075           error ("field %q+D invalidly declared method type", x);
3076           type = build_pointer_type (type);
3077           TREE_TYPE (x) = type;
3078         }
3079
3080       if (type == error_mark_node)
3081         continue;
3082
3083       if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
3084         continue;
3085
3086       /* Now it can only be a FIELD_DECL.  */
3087
3088       if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3089         CLASSTYPE_NON_AGGREGATE (t) = 1;
3090
3091       /* If at least one non-static data member is non-literal, the whole
3092          class becomes non-literal.  */
3093       if (!literal_type_p (type))
3094         CLASSTYPE_LITERAL_P (t) = false;
3095
3096       /* A standard-layout class is a class that:
3097          ...
3098          has the same access control (Clause 11) for all non-static data members,
3099          ...  */
3100       this_field_access = TREE_PROTECTED (x) ? 1 : TREE_PRIVATE (x) ? 2 : 0;
3101       if (field_access == -1)
3102         field_access = this_field_access;
3103       else if (this_field_access != field_access)
3104         CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3105
3106       /* If this is of reference type, check if it needs an init.  */
3107       if (TREE_CODE (type) == REFERENCE_TYPE)
3108         {
3109           CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3110           CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3111           if (DECL_INITIAL (x) == NULL_TREE)
3112             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3113
3114           /* ARM $12.6.2: [A member initializer list] (or, for an
3115              aggregate, initialization by a brace-enclosed list) is the
3116              only way to initialize nonstatic const and reference
3117              members.  */
3118           TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1;
3119           TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) = 1;
3120         }
3121
3122       type = strip_array_types (type);
3123
3124       if (TYPE_PACKED (t))
3125         {
3126           if (!layout_pod_type_p (type) && !TYPE_PACKED (type))
3127             {
3128               warning
3129                 (0,
3130                  "ignoring packed attribute because of unpacked non-POD field %q+#D",
3131                  x);
3132               cant_pack = 1;
3133             }
3134           else if (DECL_C_BIT_FIELD (x)
3135                    || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
3136             DECL_PACKED (x) = 1;
3137         }
3138
3139       if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
3140         /* We don't treat zero-width bitfields as making a class
3141            non-empty.  */
3142         ;
3143       else
3144         {
3145           /* The class is non-empty.  */
3146           CLASSTYPE_EMPTY_P (t) = 0;
3147           /* The class is not even nearly empty.  */
3148           CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3149           /* If one of the data members contains an empty class,
3150              so does T.  */
3151           if (CLASS_TYPE_P (type)
3152               && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3153             CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
3154         }
3155
3156       /* This is used by -Weffc++ (see below). Warn only for pointers
3157          to members which might hold dynamic memory. So do not warn
3158          for pointers to functions or pointers to members.  */
3159       if (TYPE_PTR_P (type)
3160           && !TYPE_PTRFN_P (type)
3161           && !TYPE_PTR_TO_MEMBER_P (type))
3162         has_pointers = true;
3163
3164       if (CLASS_TYPE_P (type))
3165         {
3166           if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3167             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3168           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3169             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3170         }
3171
3172       if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3173         CLASSTYPE_HAS_MUTABLE (t) = 1;
3174
3175       if (! layout_pod_type_p (type))
3176         /* DR 148 now allows pointers to members (which are POD themselves),
3177            to be allowed in POD structs.  */
3178         CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3179
3180       if (!std_layout_type_p (type))
3181         CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3182
3183       if (! zero_init_p (type))
3184         CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3185
3186       /* We set DECL_C_BIT_FIELD in grokbitfield.
3187          If the type and width are valid, we'll also set DECL_BIT_FIELD.  */
3188       if (! DECL_C_BIT_FIELD (x) || ! check_bitfield_decl (x))
3189         check_field_decl (x, t,
3190                           cant_have_const_ctor_p,
3191                           no_const_asn_ref_p,
3192                           &any_default_members);
3193
3194       /* If any field is const, the structure type is pseudo-const.  */
3195       if (CP_TYPE_CONST_P (type))
3196         {
3197           C_TYPE_FIELDS_READONLY (t) = 1;
3198           if (DECL_INITIAL (x) == NULL_TREE)
3199             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3200
3201           /* ARM $12.6.2: [A member initializer list] (or, for an
3202              aggregate, initialization by a brace-enclosed list) is the
3203              only way to initialize nonstatic const and reference
3204              members.  */
3205           TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1;
3206           TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) = 1;
3207         }
3208       /* A field that is pseudo-const makes the structure likewise.  */
3209       else if (CLASS_TYPE_P (type))
3210         {
3211           C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3212           SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3213             CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3214             | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3215         }
3216
3217       /* Core issue 80: A nonstatic data member is required to have a
3218          different name from the class iff the class has a
3219          user-declared constructor.  */
3220       if (constructor_name_p (DECL_NAME (x), t)
3221           && TYPE_HAS_USER_CONSTRUCTOR (t))
3222         permerror (input_location, "field %q+#D with same name as class", x);
3223     }
3224
3225   /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3226      it should also define a copy constructor and an assignment operator to
3227      implement the correct copy semantic (deep vs shallow, etc.). As it is
3228      not feasible to check whether the constructors do allocate dynamic memory
3229      and store it within members, we approximate the warning like this:
3230
3231      -- Warn only if there are members which are pointers
3232      -- Warn only if there is a non-trivial constructor (otherwise,
3233         there cannot be memory allocated).
3234      -- Warn only if there is a non-trivial destructor. We assume that the
3235         user at least implemented the cleanup correctly, and a destructor
3236         is needed to free dynamic memory.
3237
3238      This seems enough for practical purposes.  */
3239   if (warn_ecpp
3240       && has_pointers
3241       && TYPE_HAS_USER_CONSTRUCTOR (t)
3242       && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
3243       && !(TYPE_HAS_COPY_CTOR (t) && TYPE_HAS_COPY_ASSIGN (t)))
3244     {
3245       warning (OPT_Weffc__, "%q#T has pointer data members", t);
3246
3247       if (! TYPE_HAS_COPY_CTOR (t))
3248         {
3249           warning (OPT_Weffc__,
3250                    "  but does not override %<%T(const %T&)%>", t, t);
3251           if (!TYPE_HAS_COPY_ASSIGN (t))
3252             warning (OPT_Weffc__, "  or %<operator=(const %T&)%>", t);
3253         }
3254       else if (! TYPE_HAS_COPY_ASSIGN (t))
3255         warning (OPT_Weffc__,
3256                  "  but does not override %<operator=(const %T&)%>", t);
3257     }
3258
3259   /* Non-static data member initializers make the default constructor
3260      non-trivial.  */
3261   if (any_default_members)
3262     {
3263       TYPE_NEEDS_CONSTRUCTING (t) = true;
3264       TYPE_HAS_COMPLEX_DFLT (t) = true;
3265     }
3266
3267   /* If any of the fields couldn't be packed, unset TYPE_PACKED.  */
3268   if (cant_pack)
3269     TYPE_PACKED (t) = 0;
3270
3271   /* Check anonymous struct/anonymous union fields.  */
3272   finish_struct_anon (t);
3273
3274   /* We've built up the list of access declarations in reverse order.
3275      Fix that now.  */
3276   *access_decls = nreverse (*access_decls);
3277 }
3278
3279 /* If TYPE is an empty class type, records its OFFSET in the table of
3280    OFFSETS.  */
3281
3282 static int
3283 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3284 {
3285   splay_tree_node n;
3286
3287   if (!is_empty_class (type))
3288     return 0;
3289
3290   /* Record the location of this empty object in OFFSETS.  */
3291   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3292   if (!n)
3293     n = splay_tree_insert (offsets,
3294                            (splay_tree_key) offset,
3295                            (splay_tree_value) NULL_TREE);
3296   n->value = ((splay_tree_value)
3297               tree_cons (NULL_TREE,
3298                          type,
3299                          (tree) n->value));
3300
3301   return 0;
3302 }
3303
3304 /* Returns nonzero if TYPE is an empty class type and there is
3305    already an entry in OFFSETS for the same TYPE as the same OFFSET.  */
3306
3307 static int
3308 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3309 {
3310   splay_tree_node n;
3311   tree t;
3312
3313   if (!is_empty_class (type))
3314     return 0;
3315
3316   /* Record the location of this empty object in OFFSETS.  */
3317   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3318   if (!n)
3319     return 0;
3320
3321   for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3322     if (same_type_p (TREE_VALUE (t), type))
3323       return 1;
3324
3325   return 0;
3326 }
3327
3328 /* Walk through all the subobjects of TYPE (located at OFFSET).  Call
3329    F for every subobject, passing it the type, offset, and table of
3330    OFFSETS.  If VBASES_P is one, then virtual non-primary bases should
3331    be traversed.
3332
3333    If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3334    than MAX_OFFSET will not be walked.
3335
3336    If F returns a nonzero value, the traversal ceases, and that value
3337    is returned.  Otherwise, returns zero.  */
3338
3339 static int
3340 walk_subobject_offsets (tree type,
3341                         subobject_offset_fn f,
3342                         tree offset,
3343                         splay_tree offsets,
3344                         tree max_offset,
3345                         int vbases_p)
3346 {
3347   int r = 0;
3348   tree type_binfo = NULL_TREE;
3349
3350   /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3351      stop.  */
3352   if (max_offset && INT_CST_LT (max_offset, offset))
3353     return 0;
3354
3355   if (type == error_mark_node)
3356     return 0;
3357
3358   if (!TYPE_P (type))
3359     {
3360       if (abi_version_at_least (2))
3361         type_binfo = type;
3362       type = BINFO_TYPE (type);
3363     }
3364
3365   if (CLASS_TYPE_P (type))
3366     {
3367       tree field;
3368       tree binfo;
3369       int i;
3370
3371       /* Avoid recursing into objects that are not interesting.  */
3372       if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3373         return 0;
3374
3375       /* Record the location of TYPE.  */
3376       r = (*f) (type, offset, offsets);
3377       if (r)
3378         return r;
3379
3380       /* Iterate through the direct base classes of TYPE.  */
3381       if (!type_binfo)
3382         type_binfo = TYPE_BINFO (type);
3383       for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, binfo); i++)
3384         {
3385           tree binfo_offset;
3386
3387           if (abi_version_at_least (2)
3388               && BINFO_VIRTUAL_P (binfo))
3389             continue;
3390
3391           if (!vbases_p
3392               && BINFO_VIRTUAL_P (binfo)
3393               && !BINFO_PRIMARY_P (binfo))
3394             continue;
3395
3396           if (!abi_version_at_least (2))
3397             binfo_offset = size_binop (PLUS_EXPR,
3398                                        offset,
3399                                        BINFO_OFFSET (binfo));
3400           else
3401             {
3402               tree orig_binfo;
3403               /* We cannot rely on BINFO_OFFSET being set for the base
3404                  class yet, but the offsets for direct non-virtual
3405                  bases can be calculated by going back to the TYPE.  */
3406               orig_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
3407               binfo_offset = size_binop (PLUS_EXPR,
3408                                          offset,
3409                                          BINFO_OFFSET (orig_binfo));
3410             }
3411
3412           r = walk_subobject_offsets (binfo,
3413                                       f,
3414                                       binfo_offset,
3415                                       offsets,
3416                                       max_offset,
3417                                       (abi_version_at_least (2)
3418                                        ? /*vbases_p=*/0 : vbases_p));
3419           if (r)
3420             return r;
3421         }
3422
3423       if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type))
3424         {
3425           unsigned ix;
3426           VEC(tree,gc) *vbases;
3427
3428           /* Iterate through the virtual base classes of TYPE.  In G++
3429              3.2, we included virtual bases in the direct base class
3430              loop above, which results in incorrect results; the
3431              correct offsets for virtual bases are only known when
3432              working with the most derived type.  */
3433           if (vbases_p)
3434             for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0;
3435                  VEC_iterate (tree, vbases, ix, binfo); ix++)
3436               {
3437                 r = walk_subobject_offsets (binfo,
3438                                             f,
3439                                             size_binop (PLUS_EXPR,
3440                                                         offset,
3441                                                         BINFO_OFFSET (binfo)),
3442                                             offsets,
3443                                             max_offset,
3444                                             /*vbases_p=*/0);
3445                 if (r)
3446                   return r;
3447               }
3448           else
3449             {
3450               /* We still have to walk the primary base, if it is
3451                  virtual.  (If it is non-virtual, then it was walked
3452                  above.)  */
3453               tree vbase = get_primary_binfo (type_binfo);
3454
3455               if (vbase && BINFO_VIRTUAL_P (vbase)
3456                   && BINFO_PRIMARY_P (vbase)
3457                   && BINFO_INHERITANCE_CHAIN (vbase) == type_binfo)
3458                 {
3459                   r = (walk_subobject_offsets
3460                        (vbase, f, offset,
3461                         offsets, max_offset, /*vbases_p=*/0));
3462                   if (r)
3463                     return r;
3464                 }
3465             }
3466         }
3467
3468       /* Iterate through the fields of TYPE.  */
3469       for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
3470         if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3471           {
3472             tree field_offset;
3473
3474             if (abi_version_at_least (2))
3475               field_offset = byte_position (field);
3476             else
3477               /* In G++ 3.2, DECL_FIELD_OFFSET was used.  */
3478               field_offset = DECL_FIELD_OFFSET (field);
3479
3480             r = walk_subobject_offsets (TREE_TYPE (field),
3481                                         f,
3482                                         size_binop (PLUS_EXPR,
3483                                                     offset,
3484                                                     field_offset),
3485                                         offsets,
3486                                         max_offset,
3487                                         /*vbases_p=*/1);
3488             if (r)
3489               return r;
3490           }
3491     }
3492   else if (TREE_CODE (type) == ARRAY_TYPE)
3493     {
3494       tree element_type = strip_array_types (type);
3495       tree domain = TYPE_DOMAIN (type);
3496       tree index;
3497
3498       /* Avoid recursing into objects that are not interesting.  */
3499       if (!CLASS_TYPE_P (element_type)
3500           || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3501         return 0;
3502
3503       /* Step through each of the elements in the array.  */
3504       for (index = size_zero_node;
3505            /* G++ 3.2 had an off-by-one error here.  */
3506            (abi_version_at_least (2)
3507             ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3508             : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3509            index = size_binop (PLUS_EXPR, index, size_one_node))
3510         {
3511           r = walk_subobject_offsets (TREE_TYPE (type),
3512                                       f,
3513                                       offset,
3514                                       offsets,
3515                                       max_offset,
3516                                       /*vbases_p=*/1);
3517           if (r)
3518             return r;
3519           offset = size_binop (PLUS_EXPR, offset,
3520                                TYPE_SIZE_UNIT (TREE_TYPE (type)));
3521           /* If this new OFFSET is bigger than the MAX_OFFSET, then
3522              there's no point in iterating through the remaining
3523              elements of the array.  */
3524           if (max_offset && INT_CST_LT (max_offset, offset))
3525             break;
3526         }
3527     }
3528
3529   return 0;
3530 }
3531
3532 /* Record all of the empty subobjects of TYPE (either a type or a
3533    binfo).  If IS_DATA_MEMBER is true, then a non-static data member
3534    is being placed at OFFSET; otherwise, it is a base class that is
3535    being placed at OFFSET.  */
3536
3537 static void
3538 record_subobject_offsets (tree type,
3539                           tree offset,
3540                           splay_tree offsets,
3541                           bool is_data_member)
3542 {
3543   tree max_offset;
3544   /* If recording subobjects for a non-static data member or a
3545      non-empty base class , we do not need to record offsets beyond
3546      the size of the biggest empty class.  Additional data members
3547      will go at the end of the class.  Additional base classes will go
3548      either at offset zero (if empty, in which case they cannot
3549      overlap with offsets past the size of the biggest empty class) or
3550      at the end of the class.
3551
3552      However, if we are placing an empty base class, then we must record
3553      all offsets, as either the empty class is at offset zero (where
3554      other empty classes might later be placed) or at the end of the
3555      class (where other objects might then be placed, so other empty
3556      subobjects might later overlap).  */
3557   if (is_data_member
3558       || !is_empty_class (BINFO_TYPE (type)))
3559     max_offset = sizeof_biggest_empty_class;
3560   else
3561     max_offset = NULL_TREE;
3562   walk_subobject_offsets (type, record_subobject_offset, offset,
3563                           offsets, max_offset, is_data_member);
3564 }
3565
3566 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3567    OFFSET) conflict with entries in OFFSETS.  If VBASES_P is nonzero,
3568    virtual bases of TYPE are examined.  */
3569
3570 static int
3571 layout_conflict_p (tree type,
3572                    tree offset,
3573                    splay_tree offsets,
3574                    int vbases_p)
3575 {
3576   splay_tree_node max_node;
3577
3578   /* Get the node in OFFSETS that indicates the maximum offset where
3579      an empty subobject is located.  */
3580   max_node = splay_tree_max (offsets);
3581   /* If there aren't any empty subobjects, then there's no point in
3582      performing this check.  */
3583   if (!max_node)
3584     return 0;
3585
3586   return walk_subobject_offsets (type, check_subobject_offset, offset,
3587                                  offsets, (tree) (max_node->key),
3588                                  vbases_p);
3589 }
3590
3591 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3592    non-static data member of the type indicated by RLI.  BINFO is the
3593    binfo corresponding to the base subobject, OFFSETS maps offsets to
3594    types already located at those offsets.  This function determines
3595    the position of the DECL.  */
3596
3597 static void
3598 layout_nonempty_base_or_field (record_layout_info rli,
3599                                tree decl,
3600                                tree binfo,
3601                                splay_tree offsets)
3602 {
3603   tree offset = NULL_TREE;
3604   bool field_p;
3605   tree type;
3606
3607   if (binfo)
3608     {
3609       /* For the purposes of determining layout conflicts, we want to
3610          use the class type of BINFO; TREE_TYPE (DECL) will be the
3611          CLASSTYPE_AS_BASE version, which does not contain entries for
3612          zero-sized bases.  */
3613       type = TREE_TYPE (binfo);
3614       field_p = false;
3615     }
3616   else
3617     {
3618       type = TREE_TYPE (decl);
3619       field_p = true;
3620     }
3621
3622   /* Try to place the field.  It may take more than one try if we have
3623      a hard time placing the field without putting two objects of the
3624      same type at the same address.  */
3625   while (1)
3626     {
3627       struct record_layout_info_s old_rli = *rli;
3628
3629       /* Place this field.  */
3630       place_field (rli, decl);
3631       offset = byte_position (decl);
3632
3633       /* We have to check to see whether or not there is already
3634          something of the same type at the offset we're about to use.
3635          For example, consider:
3636
3637            struct S {};
3638            struct T : public S { int i; };
3639            struct U : public S, public T {};
3640
3641          Here, we put S at offset zero in U.  Then, we can't put T at
3642          offset zero -- its S component would be at the same address
3643          as the S we already allocated.  So, we have to skip ahead.
3644          Since all data members, including those whose type is an
3645          empty class, have nonzero size, any overlap can happen only
3646          with a direct or indirect base-class -- it can't happen with
3647          a data member.  */
3648       /* In a union, overlap is permitted; all members are placed at
3649          offset zero.  */
3650       if (TREE_CODE (rli->t) == UNION_TYPE)
3651         break;
3652       /* G++ 3.2 did not check for overlaps when placing a non-empty
3653          virtual base.  */
3654       if (!abi_version_at_least (2) && binfo && BINFO_VIRTUAL_P (binfo))
3655         break;
3656       if (layout_conflict_p (field_p ? type : binfo, offset,
3657                              offsets, field_p))
3658         {
3659           /* Strip off the size allocated to this field.  That puts us
3660              at the first place we could have put the field with
3661              proper alignment.  */
3662           *rli = old_rli;
3663
3664           /* Bump up by the alignment required for the type.  */
3665           rli->bitpos
3666             = size_binop (PLUS_EXPR, rli->bitpos,
3667                           bitsize_int (binfo
3668                                        ? CLASSTYPE_ALIGN (type)
3669                                        : TYPE_ALIGN (type)));
3670           normalize_rli (rli);
3671         }
3672       else
3673         /* There was no conflict.  We're done laying out this field.  */
3674         break;
3675     }
3676
3677   /* Now that we know where it will be placed, update its
3678      BINFO_OFFSET.  */
3679   if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3680     /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3681        this point because their BINFO_OFFSET is copied from another
3682        hierarchy.  Therefore, we may not need to add the entire
3683        OFFSET.  */
3684     propagate_binfo_offsets (binfo,
3685                              size_diffop_loc (input_location,
3686                                           convert (ssizetype, offset),
3687                                           convert (ssizetype,
3688                                                    BINFO_OFFSET (binfo))));
3689 }
3690
3691 /* Returns true if TYPE is empty and OFFSET is nonzero.  */
3692
3693 static int
3694 empty_base_at_nonzero_offset_p (tree type,
3695                                 tree offset,
3696                                 splay_tree offsets ATTRIBUTE_UNUSED)
3697 {
3698   return is_empty_class (type) && !integer_zerop (offset);
3699 }
3700
3701 /* Layout the empty base BINFO.  EOC indicates the byte currently just
3702    past the end of the class, and should be correctly aligned for a
3703    class of the type indicated by BINFO; OFFSETS gives the offsets of
3704    the empty bases allocated so far. T is the most derived
3705    type.  Return nonzero iff we added it at the end.  */
3706
3707 static bool
3708 layout_empty_base (record_layout_info rli, tree binfo,
3709                    tree eoc, splay_tree offsets)
3710 {
3711   tree alignment;
3712   tree basetype = BINFO_TYPE (binfo);
3713   bool atend = false;
3714
3715   /* This routine should only be used for empty classes.  */
3716   gcc_assert (is_empty_class (basetype));
3717   alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3718
3719   if (!integer_zerop (BINFO_OFFSET (binfo)))
3720     {
3721       if (abi_version_at_least (2))
3722         propagate_binfo_offsets
3723           (binfo, size_diffop_loc (input_location,
3724                                size_zero_node, BINFO_OFFSET (binfo)));
3725       else
3726         warning (OPT_Wabi,
3727                  "offset of empty base %qT may not be ABI-compliant and may"
3728                  "change in a future version of GCC",
3729                  BINFO_TYPE (binfo));
3730     }
3731
3732   /* This is an empty base class.  We first try to put it at offset
3733      zero.  */
3734   if (layout_conflict_p (binfo,
3735                          BINFO_OFFSET (binfo),
3736                          offsets,
3737                          /*vbases_p=*/0))
3738     {
3739       /* That didn't work.  Now, we move forward from the next
3740          available spot in the class.  */
3741       atend = true;
3742       propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3743       while (1)
3744         {
3745           if (!layout_conflict_p (binfo,
3746                                   BINFO_OFFSET (binfo),
3747                                   offsets,
3748                                   /*vbases_p=*/0))
3749             /* We finally found a spot where there's no overlap.  */
3750             break;
3751
3752           /* There's overlap here, too.  Bump along to the next spot.  */
3753           propagate_binfo_offsets (binfo, alignment);
3754         }
3755     }
3756
3757   if (CLASSTYPE_USER_ALIGN (basetype))
3758     {
3759       rli->record_align = MAX (rli->record_align, CLASSTYPE_ALIGN (basetype));
3760       if (warn_packed)
3761         rli->unpacked_align = MAX (rli->unpacked_align, CLASSTYPE_ALIGN (basetype));
3762       TYPE_USER_ALIGN (rli->t) = 1;
3763     }
3764
3765   return atend;
3766 }
3767
3768 /* Layout the base given by BINFO in the class indicated by RLI.
3769    *BASE_ALIGN is a running maximum of the alignments of
3770    any base class.  OFFSETS gives the location of empty base
3771    subobjects.  T is the most derived type.  Return nonzero if the new
3772    object cannot be nearly-empty.  A new FIELD_DECL is inserted at
3773    *NEXT_FIELD, unless BINFO is for an empty base class.
3774
3775    Returns the location at which the next field should be inserted.  */
3776
3777 static tree *
3778 build_base_field (record_layout_info rli, tree binfo,
3779                   splay_tree offsets, tree *next_field)
3780 {
3781   tree t = rli->t;
3782   tree basetype = BINFO_TYPE (binfo);
3783
3784   if (!COMPLETE_TYPE_P (basetype))
3785     /* This error is now reported in xref_tag, thus giving better
3786        location information.  */
3787     return next_field;
3788
3789   /* Place the base class.  */
3790   if (!is_empty_class (basetype))
3791     {
3792       tree decl;
3793
3794       /* The containing class is non-empty because it has a non-empty
3795          base class.  */
3796       CLASSTYPE_EMPTY_P (t) = 0;
3797
3798       /* Create the FIELD_DECL.  */
3799       decl = build_decl (input_location,
3800                          FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3801       DECL_ARTIFICIAL (decl) = 1;
3802       DECL_IGNORED_P (decl) = 1;
3803       DECL_FIELD_CONTEXT (decl) = t;
3804       if (CLASSTYPE_AS_BASE (basetype))
3805         {
3806           DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3807           DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3808           DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3809           DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3810           DECL_MODE (decl) = TYPE_MODE (basetype);
3811           DECL_FIELD_IS_BASE (decl) = 1;
3812
3813           /* Try to place the field.  It may take more than one try if we
3814              have a hard time placing the field without putting two
3815              objects of the same type at the same address.  */
3816           layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3817           /* Add the new FIELD_DECL to the list of fields for T.  */
3818           DECL_CHAIN (decl) = *next_field;
3819           *next_field = decl;
3820           next_field = &DECL_CHAIN (decl);
3821         }
3822     }
3823   else
3824     {
3825       tree eoc;
3826       bool atend;
3827
3828       /* On some platforms (ARM), even empty classes will not be
3829          byte-aligned.  */
3830       eoc = round_up_loc (input_location,
3831                       rli_size_unit_so_far (rli),
3832                       CLASSTYPE_ALIGN_UNIT (basetype));
3833       atend = layout_empty_base (rli, binfo, eoc, offsets);
3834       /* A nearly-empty class "has no proper base class that is empty,
3835          not morally virtual, and at an offset other than zero."  */
3836       if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3837         {
3838           if (atend)
3839             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3840           /* The check above (used in G++ 3.2) is insufficient because
3841              an empty class placed at offset zero might itself have an
3842              empty base at a nonzero offset.  */
3843           else if (walk_subobject_offsets (basetype,
3844                                            empty_base_at_nonzero_offset_p,
3845                                            size_zero_node,
3846                                            /*offsets=*/NULL,
3847                                            /*max_offset=*/NULL_TREE,
3848                                            /*vbases_p=*/true))
3849             {
3850               if (abi_version_at_least (2))
3851                 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3852               else
3853                 warning (OPT_Wabi,
3854                          "class %qT will be considered nearly empty in a "
3855                          "future version of GCC", t);
3856             }
3857         }
3858
3859       /* We do not create a FIELD_DECL for empty base classes because
3860          it might overlap some other field.  We want to be able to
3861          create CONSTRUCTORs for the class by iterating over the
3862          FIELD_DECLs, and the back end does not handle overlapping
3863          FIELD_DECLs.  */
3864
3865       /* An empty virtual base causes a class to be non-empty
3866          -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3867          here because that was already done when the virtual table
3868          pointer was created.  */
3869     }
3870
3871   /* Record the offsets of BINFO and its base subobjects.  */
3872   record_subobject_offsets (binfo,
3873                             BINFO_OFFSET (binfo),
3874                             offsets,
3875                             /*is_data_member=*/false);
3876
3877   return next_field;
3878 }
3879
3880 /* Layout all of the non-virtual base classes.  Record empty
3881    subobjects in OFFSETS.  T is the most derived type.  Return nonzero
3882    if the type cannot be nearly empty.  The fields created
3883    corresponding to the base classes will be inserted at
3884    *NEXT_FIELD.  */
3885
3886 static void
3887 build_base_fields (record_layout_info rli,
3888                    splay_tree offsets, tree *next_field)
3889 {
3890   /* Chain to hold all the new FIELD_DECLs which stand in for base class
3891      subobjects.  */
3892   tree t = rli->t;
3893   int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
3894   int i;
3895
3896   /* The primary base class is always allocated first.  */
3897   if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3898     next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3899                                    offsets, next_field);
3900
3901   /* Now allocate the rest of the bases.  */
3902   for (i = 0; i < n_baseclasses; ++i)
3903     {
3904       tree base_binfo;
3905
3906       base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
3907
3908       /* The primary base was already allocated above, so we don't
3909          need to allocate it again here.  */
3910       if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3911         continue;
3912
3913       /* Virtual bases are added at the end (a primary virtual base
3914          will have already been added).  */
3915       if (BINFO_VIRTUAL_P (base_binfo))
3916         continue;
3917
3918       next_field = build_base_field (rli, base_binfo,
3919                                      offsets, next_field);
3920     }
3921 }
3922
3923 /* Go through the TYPE_METHODS of T issuing any appropriate
3924    diagnostics, figuring out which methods override which other
3925    methods, and so forth.  */
3926
3927 static void
3928 check_methods (tree t)
3929 {
3930   tree x;
3931
3932   for (x = TYPE_METHODS (t); x; x = DECL_CHAIN (x))
3933     {
3934       check_for_override (x, t);
3935       if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3936         error ("initializer specified for non-virtual method %q+D", x);
3937       /* The name of the field is the original field name
3938          Save this in auxiliary field for later overloading.  */
3939       if (DECL_VINDEX (x))
3940         {
3941           TYPE_POLYMORPHIC_P (t) = 1;
3942           if (DECL_PURE_VIRTUAL_P (x))
3943             VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
3944         }
3945       /* All user-provided destructors are non-trivial.
3946          Constructors and assignment ops are handled in
3947          grok_special_member_properties.  */
3948       if (DECL_DESTRUCTOR_P (x) && user_provided_p (x))
3949         TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 1;
3950     }
3951 }
3952
3953 /* FN is a constructor or destructor.  Clone the declaration to create
3954    a specialized in-charge or not-in-charge version, as indicated by
3955    NAME.  */
3956
3957 static tree
3958 build_clone (tree fn, tree name)
3959 {
3960   tree parms;
3961   tree clone;
3962
3963   /* Copy the function.  */
3964   clone = copy_decl (fn);
3965   /* Reset the function name.  */
3966   DECL_NAME (clone) = name;
3967   SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3968   /* Remember where this function came from.  */
3969   DECL_ABSTRACT_ORIGIN (clone) = fn;
3970   /* Make it easy to find the CLONE given the FN.  */
3971   DECL_CHAIN (clone) = DECL_CHAIN (fn);
3972   DECL_CHAIN (fn) = clone;
3973
3974   /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT.  */
3975   if (TREE_CODE (clone) == TEMPLATE_DECL)
3976     {
3977       tree result = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3978       DECL_TEMPLATE_RESULT (clone) = result;
3979       DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3980       DECL_TI_TEMPLATE (result) = clone;
3981       TREE_TYPE (clone) = TREE_TYPE (result);
3982       return clone;
3983     }
3984
3985   DECL_CLONED_FUNCTION (clone) = fn;
3986   /* There's no pending inline data for this function.  */
3987   DECL_PENDING_INLINE_INFO (clone) = NULL;
3988   DECL_PENDING_INLINE_P (clone) = 0;
3989
3990   /* The base-class destructor is not virtual.  */
3991   if (name == base_dtor_identifier)
3992     {
3993       DECL_VIRTUAL_P (clone) = 0;
3994       if (TREE_CODE (clone) != TEMPLATE_DECL)
3995         DECL_VINDEX (clone) = NULL_TREE;
3996     }
3997
3998   /* If there was an in-charge parameter, drop it from the function
3999      type.  */
4000   if (DECL_HAS_IN_CHARGE_PARM_P (clone))
4001     {
4002       tree basetype;
4003       tree parmtypes;
4004       tree exceptions;
4005
4006       exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
4007       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
4008       parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
4009       /* Skip the `this' parameter.  */
4010       parmtypes = TREE_CHAIN (parmtypes);
4011       /* Skip the in-charge parameter.  */
4012       parmtypes = TREE_CHAIN (parmtypes);
4013       /* And the VTT parm, in a complete [cd]tor.  */
4014       if (DECL_HAS_VTT_PARM_P (fn)
4015           && ! DECL_NEEDS_VTT_PARM_P (clone))
4016         parmtypes = TREE_CHAIN (parmtypes);
4017        /* If this is subobject constructor or destructor, add the vtt
4018          parameter.  */
4019       TREE_TYPE (clone)
4020         = build_method_type_directly (basetype,
4021                                       TREE_TYPE (TREE_TYPE (clone)),
4022                                       parmtypes);
4023       if (exceptions)
4024         TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
4025                                                      exceptions);
4026       TREE_TYPE (clone)
4027         = cp_build_type_attribute_variant (TREE_TYPE (clone),
4028                                            TYPE_ATTRIBUTES (TREE_TYPE (fn)));
4029     }
4030
4031   /* Copy the function parameters.  */
4032   DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
4033   /* Remove the in-charge parameter.  */
4034   if (DECL_HAS_IN_CHARGE_PARM_P (clone))
4035     {
4036       DECL_CHAIN (DECL_ARGUMENTS (clone))
4037         = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone)));
4038       DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
4039     }
4040   /* And the VTT parm, in a complete [cd]tor.  */
4041   if (DECL_HAS_VTT_PARM_P (fn))
4042     {
4043       if (DECL_NEEDS_VTT_PARM_P (clone))
4044         DECL_HAS_VTT_PARM_P (clone) = 1;
4045       else
4046         {
4047           DECL_CHAIN (DECL_ARGUMENTS (clone))
4048             = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone)));
4049           DECL_HAS_VTT_PARM_P (clone) = 0;
4050         }
4051     }
4052
4053   for (parms = DECL_ARGUMENTS (clone); parms; parms = DECL_CHAIN (parms))
4054     {
4055       DECL_CONTEXT (parms) = clone;
4056       cxx_dup_lang_specific_decl (parms);
4057     }
4058
4059   /* Create the RTL for this function.  */
4060   SET_DECL_RTL (clone, NULL);
4061   rest_of_decl_compilation (clone, /*top_level=*/1, at_eof);
4062
4063   if (pch_file)
4064     note_decl_for_pch (clone);
4065
4066   return clone;
4067 }
4068
4069 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
4070    not invoke this function directly.
4071
4072    For a non-thunk function, returns the address of the slot for storing
4073    the function it is a clone of.  Otherwise returns NULL_TREE.
4074
4075    If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
4076    cloned_function is unset.  This is to support the separate
4077    DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
4078    on a template makes sense, but not the former.  */
4079
4080 tree *
4081 decl_cloned_function_p (const_tree decl, bool just_testing)
4082 {
4083   tree *ptr;
4084   if (just_testing)
4085     decl = STRIP_TEMPLATE (decl);
4086
4087   if (TREE_CODE (decl) != FUNCTION_DECL
4088       || !DECL_LANG_SPECIFIC (decl)
4089       || DECL_LANG_SPECIFIC (decl)->u.fn.thunk_p)
4090     {
4091 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4092       if (!just_testing)
4093         lang_check_failed (__FILE__, __LINE__, __FUNCTION__);
4094       else
4095 #endif
4096         return NULL;
4097     }
4098
4099   ptr = &DECL_LANG_SPECIFIC (decl)->u.fn.u5.cloned_function;
4100   if (just_testing && *ptr == NULL_TREE)
4101     return NULL;
4102   else
4103     return ptr;
4104 }
4105
4106 /* Produce declarations for all appropriate clones of FN.  If
4107    UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4108    CLASTYPE_METHOD_VEC as well.  */
4109
4110 void
4111 clone_function_decl (tree fn, int update_method_vec_p)
4112 {
4113   tree clone;
4114
4115   /* Avoid inappropriate cloning.  */
4116   if (DECL_CHAIN (fn)
4117       && DECL_CLONED_FUNCTION_P (DECL_CHAIN (fn)))
4118     return;
4119
4120   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
4121     {
4122       /* For each constructor, we need two variants: an in-charge version
4123          and a not-in-charge version.  */
4124       clone = build_clone (fn, complete_ctor_identifier);
4125       if (update_method_vec_p)
4126         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4127       clone = build_clone (fn, base_ctor_identifier);
4128       if (update_method_vec_p)
4129         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4130     }
4131   else
4132     {
4133       gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn));
4134
4135       /* For each destructor, we need three variants: an in-charge
4136          version, a not-in-charge version, and an in-charge deleting
4137          version.  We clone the deleting version first because that
4138          means it will go second on the TYPE_METHODS list -- and that
4139          corresponds to the correct layout order in the virtual
4140          function table.
4141
4142          For a non-virtual destructor, we do not build a deleting
4143          destructor.  */
4144       if (DECL_VIRTUAL_P (fn))
4145         {
4146           clone = build_clone (fn, deleting_dtor_identifier);
4147           if (update_method_vec_p)
4148             add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4149         }
4150       clone = build_clone (fn, complete_dtor_identifier);
4151       if (update_method_vec_p)
4152         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4153       clone = build_clone (fn, base_dtor_identifier);
4154       if (update_method_vec_p)
4155         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4156     }
4157
4158   /* Note that this is an abstract function that is never emitted.  */
4159   DECL_ABSTRACT (fn) = 1;
4160 }
4161
4162 /* DECL is an in charge constructor, which is being defined. This will
4163    have had an in class declaration, from whence clones were
4164    declared. An out-of-class definition can specify additional default
4165    arguments. As it is the clones that are involved in overload
4166    resolution, we must propagate the information from the DECL to its
4167    clones.  */
4168
4169 void
4170 adjust_clone_args (tree decl)
4171 {
4172   tree clone;
4173
4174   for (clone = DECL_CHAIN (decl); clone && DECL_CLONED_FUNCTION_P (clone);
4175        clone = DECL_CHAIN (clone))
4176     {
4177       tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone));
4178       tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
4179       tree decl_parms, clone_parms;
4180
4181       clone_parms = orig_clone_parms;
4182
4183       /* Skip the 'this' parameter.  */
4184       orig_clone_parms = TREE_CHAIN (orig_clone_parms);
4185       orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4186
4187       if (DECL_HAS_IN_CHARGE_PARM_P (decl))
4188         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4189       if (DECL_HAS_VTT_PARM_P (decl))
4190         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4191
4192       clone_parms = orig_clone_parms;
4193       if (DECL_HAS_VTT_PARM_P (clone))
4194         clone_parms = TREE_CHAIN (clone_parms);
4195
4196       for (decl_parms = orig_decl_parms; decl_parms;
4197            decl_parms = TREE_CHAIN (decl_parms),
4198              clone_parms = TREE_CHAIN (clone_parms))
4199         {
4200           gcc_assert (same_type_p (TREE_TYPE (decl_parms),
4201                                    TREE_TYPE (clone_parms)));
4202
4203           if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
4204             {
4205               /* A default parameter has been added. Adjust the
4206                  clone's parameters.  */
4207               tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
4208               tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (clone));
4209               tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
4210               tree type;
4211
4212               clone_parms = orig_decl_parms;
4213
4214               if (DECL_HAS_VTT_PARM_P (clone))
4215                 {
4216                   clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
4217                                            TREE_VALUE (orig_clone_parms),
4218                                            clone_parms);
4219                   TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
4220                 }
4221               type = build_method_type_directly (basetype,
4222                                                  TREE_TYPE (TREE_TYPE (clone)),
4223                                                  clone_parms);
4224               if (exceptions)
4225                 type = build_exception_variant (type, exceptions);
4226               if (attrs)
4227                 type = cp_build_type_attribute_variant (type, attrs);
4228               TREE_TYPE (clone) = type;
4229
4230               clone_parms = NULL_TREE;
4231               break;
4232             }
4233         }
4234       gcc_assert (!clone_parms);
4235     }
4236 }
4237
4238 /* For each of the constructors and destructors in T, create an
4239    in-charge and not-in-charge variant.  */
4240
4241 static void
4242 clone_constructors_and_destructors (tree t)
4243 {
4244   tree fns;
4245
4246   /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4247      out now.  */
4248   if (!CLASSTYPE_METHOD_VEC (t))
4249     return;
4250
4251   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4252     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4253   for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4254     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4255 }
4256
4257 /* Returns true iff class T has a user-defined constructor other than
4258    the default constructor.  */
4259
4260 bool
4261 type_has_user_nondefault_constructor (tree t)
4262 {
4263   tree fns;
4264
4265   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4266     return false;
4267
4268   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4269     {
4270       tree fn = OVL_CURRENT (fns);
4271       if (!DECL_ARTIFICIAL (fn)
4272           && (TREE_CODE (fn) == TEMPLATE_DECL
4273               || (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn))
4274                   != NULL_TREE)))
4275         return true;
4276     }
4277
4278   return false;
4279 }
4280
4281 /* Returns the defaulted constructor if T has one. Otherwise, returns
4282    NULL_TREE.  */
4283
4284 tree
4285 in_class_defaulted_default_constructor (tree t)
4286 {
4287   tree fns, args;
4288
4289   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4290     return NULL_TREE;
4291
4292   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4293     {
4294       tree fn = OVL_CURRENT (fns);
4295
4296       if (DECL_DEFAULTED_IN_CLASS_P (fn))
4297         {
4298           args = FUNCTION_FIRST_USER_PARMTYPE (fn);
4299           while (args && TREE_PURPOSE (args))
4300             args = TREE_CHAIN (args);
4301           if (!args || args == void_list_node)
4302             return fn;
4303         }
4304     }
4305
4306   return NULL_TREE;
4307 }
4308
4309 /* Returns true iff FN is a user-provided function, i.e. user-declared
4310    and not defaulted at its first declaration; or explicit, private,
4311    protected, or non-const.  */
4312
4313 bool
4314 user_provided_p (tree fn)
4315 {
4316   if (TREE_CODE (fn) == TEMPLATE_DECL)
4317     return true;
4318   else
4319     return (!DECL_ARTIFICIAL (fn)
4320             && !DECL_DEFAULTED_IN_CLASS_P (fn));
4321 }
4322
4323 /* Returns true iff class T has a user-provided constructor.  */
4324
4325 bool
4326 type_has_user_provided_constructor (tree t)
4327 {
4328   tree fns;
4329
4330   if (!CLASS_TYPE_P (t))
4331     return false;
4332
4333   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4334     return false;
4335
4336   /* This can happen in error cases; avoid crashing.  */
4337   if (!CLASSTYPE_METHOD_VEC (t))
4338     return false;
4339
4340   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4341     if (user_provided_p (OVL_CURRENT (fns)))
4342       return true;
4343
4344   return false;
4345 }
4346
4347 /* Returns true iff class T has a user-provided default constructor.  */
4348
4349 bool
4350 type_has_user_provided_default_constructor (tree t)
4351 {
4352   tree fns;
4353
4354   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4355     return false;
4356
4357   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4358     {
4359       tree fn = OVL_CURRENT (fns);
4360       if (TREE_CODE (fn) == FUNCTION_DECL
4361           && user_provided_p (fn)
4362           && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn)))
4363         return true;
4364     }
4365
4366   return false;
4367 }
4368
4369 /* If default-initialization leaves part of TYPE uninitialized, returns
4370    a DECL for the field or TYPE itself (DR 253).  */
4371
4372 tree
4373 default_init_uninitialized_part (tree type)
4374 {
4375   tree t, r, binfo;
4376   int i;
4377
4378   type = strip_array_types (type);
4379   if (!CLASS_TYPE_P (type))
4380     return type;
4381   if (type_has_user_provided_default_constructor (type))
4382     return NULL_TREE;
4383   for (binfo = TYPE_BINFO (type), i = 0;
4384        BINFO_BASE_ITERATE (binfo, i, t); ++i)
4385     {
4386       r = default_init_uninitialized_part (BINFO_TYPE (t));
4387       if (r)
4388         return r;
4389     }
4390   for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
4391     if (TREE_CODE (t) == FIELD_DECL
4392         && !DECL_ARTIFICIAL (t)
4393         && !DECL_INITIAL (t))
4394       {
4395         r = default_init_uninitialized_part (TREE_TYPE (t));
4396         if (r)
4397           return DECL_P (r) ? r : t;
4398       }
4399
4400   return NULL_TREE;
4401 }
4402
4403 /* Returns true iff for class T, a trivial synthesized default constructor
4404    would be constexpr.  */
4405
4406 bool
4407 trivial_default_constructor_is_constexpr (tree t)
4408 {
4409   /* A defaulted trivial default constructor is constexpr
4410      if there is nothing to initialize.  */
4411   gcc_assert (!TYPE_HAS_COMPLEX_DFLT (t));
4412   return is_really_empty_class (t);
4413 }
4414
4415 /* Returns true iff class T has a constexpr default constructor.  */
4416
4417 bool
4418 type_has_constexpr_default_constructor (tree t)
4419 {
4420   tree fns;
4421
4422   if (!CLASS_TYPE_P (t))
4423     {
4424       /* The caller should have stripped an enclosing array.  */
4425       gcc_assert (TREE_CODE (t) != ARRAY_TYPE);
4426       return false;
4427     }
4428   if (CLASSTYPE_LAZY_DEFAULT_CTOR (t))
4429     {
4430       if (!TYPE_HAS_COMPLEX_DFLT (t))
4431         return trivial_default_constructor_is_constexpr (t);
4432       /* Non-trivial, we need to check subobject constructors.  */
4433       lazily_declare_fn (sfk_constructor, t);
4434     }
4435   fns = locate_ctor (t);
4436   return (fns && DECL_DECLARED_CONSTEXPR_P (fns));
4437 }
4438
4439 /* Returns true iff class TYPE has a virtual destructor.  */
4440
4441 bool
4442 type_has_virtual_destructor (tree type)
4443 {
4444   tree dtor;
4445
4446   if (!CLASS_TYPE_P (type))
4447     return false;
4448
4449   gcc_assert (COMPLETE_TYPE_P (type));
4450   dtor = CLASSTYPE_DESTRUCTORS (type);
4451   return (dtor && DECL_VIRTUAL_P (dtor));
4452 }
4453
4454 /* Returns true iff class T has a move constructor.  */
4455
4456 bool
4457 type_has_move_constructor (tree t)
4458 {
4459   tree fns;
4460
4461   if (CLASSTYPE_LAZY_MOVE_CTOR (t))
4462     {
4463       gcc_assert (COMPLETE_TYPE_P (t));
4464       lazily_declare_fn (sfk_move_constructor, t);
4465     }
4466
4467   if (!CLASSTYPE_METHOD_VEC (t))
4468     return false;
4469
4470   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4471     if (move_fn_p (OVL_CURRENT (fns)))
4472       return true;
4473
4474   return false;
4475 }
4476
4477 /* Returns true iff class T has a move assignment operator.  */
4478
4479 bool
4480 type_has_move_assign (tree t)
4481 {
4482   tree fns;
4483
4484   if (CLASSTYPE_LAZY_MOVE_ASSIGN (t))
4485     {
4486       gcc_assert (COMPLETE_TYPE_P (t));
4487       lazily_declare_fn (sfk_move_assignment, t);
4488     }
4489
4490   for (fns = lookup_fnfields_slot (t, ansi_assopname (NOP_EXPR));
4491        fns; fns = OVL_NEXT (fns))
4492     if (move_fn_p (OVL_CURRENT (fns)))
4493       return true;
4494
4495   return false;
4496 }
4497
4498 /* Nonzero if we need to build up a constructor call when initializing an
4499    object of this class, either because it has a user-provided constructor
4500    or because it doesn't have a default constructor (so we need to give an
4501    error if no initializer is provided).  Use TYPE_NEEDS_CONSTRUCTING when
4502    what you care about is whether or not an object can be produced by a
4503    constructor (e.g. so we don't set TREE_READONLY on const variables of
4504    such type); use this function when what you care about is whether or not
4505    to try to call a constructor to create an object.  The latter case is
4506    the former plus some cases of constructors that cannot be called.  */
4507
4508 bool
4509 type_build_ctor_call (tree t)
4510 {
4511   tree inner;
4512   if (TYPE_NEEDS_CONSTRUCTING (t))
4513     return true;
4514   inner = strip_array_types (t);
4515   return (CLASS_TYPE_P (inner) && !TYPE_HAS_DEFAULT_CONSTRUCTOR (inner)
4516           && !ANON_AGGR_TYPE_P (inner));
4517 }
4518
4519 /* Remove all zero-width bit-fields from T.  */
4520
4521 static void
4522 remove_zero_width_bit_fields (tree t)
4523 {
4524   tree *fieldsp;
4525
4526   fieldsp = &TYPE_FIELDS (t);
4527   while (*fieldsp)
4528     {
4529       if (TREE_CODE (*fieldsp) == FIELD_DECL
4530           && DECL_C_BIT_FIELD (*fieldsp)
4531           /* We should not be confused by the fact that grokbitfield
4532              temporarily sets the width of the bit field into
4533              DECL_INITIAL (*fieldsp).
4534              check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
4535              to that width.  */
4536           && integer_zerop (DECL_SIZE (*fieldsp)))
4537         *fieldsp = DECL_CHAIN (*fieldsp);
4538       else
4539         fieldsp = &DECL_CHAIN (*fieldsp);
4540     }
4541 }
4542
4543 /* Returns TRUE iff we need a cookie when dynamically allocating an
4544    array whose elements have the indicated class TYPE.  */
4545
4546 static bool
4547 type_requires_array_cookie (tree type)
4548 {
4549   tree fns;
4550   bool has_two_argument_delete_p = false;
4551
4552   gcc_assert (CLASS_TYPE_P (type));
4553
4554   /* If there's a non-trivial destructor, we need a cookie.  In order
4555      to iterate through the array calling the destructor for each
4556      element, we'll have to know how many elements there are.  */
4557   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4558     return true;
4559
4560   /* If the usual deallocation function is a two-argument whose second
4561      argument is of type `size_t', then we have to pass the size of
4562      the array to the deallocation function, so we will need to store
4563      a cookie.  */
4564   fns = lookup_fnfields (TYPE_BINFO (type),
4565                          ansi_opname (VEC_DELETE_EXPR),
4566                          /*protect=*/0);
4567   /* If there are no `operator []' members, or the lookup is
4568      ambiguous, then we don't need a cookie.  */
4569   if (!fns || fns == error_mark_node)
4570     return false;
4571   /* Loop through all of the functions.  */
4572   for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4573     {
4574       tree fn;
4575       tree second_parm;
4576
4577       /* Select the current function.  */
4578       fn = OVL_CURRENT (fns);
4579       /* See if this function is a one-argument delete function.  If
4580          it is, then it will be the usual deallocation function.  */
4581       second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4582       if (second_parm == void_list_node)
4583         return false;
4584       /* Do not consider this function if its second argument is an
4585          ellipsis.  */
4586       if (!second_parm)
4587         continue;
4588       /* Otherwise, if we have a two-argument function and the second
4589          argument is `size_t', it will be the usual deallocation
4590          function -- unless there is one-argument function, too.  */
4591       if (TREE_CHAIN (second_parm) == void_list_node
4592           && same_type_p (TREE_VALUE (second_parm), size_type_node))
4593         has_two_argument_delete_p = true;
4594     }
4595
4596   return has_two_argument_delete_p;
4597 }
4598
4599 /* Finish computing the `literal type' property of class type T.
4600
4601    At this point, we have already processed base classes and
4602    non-static data members.  We need to check whether the copy
4603    constructor is trivial, the destructor is trivial, and there
4604    is a trivial default constructor or at least one constexpr
4605    constructor other than the copy constructor.  */
4606
4607 static void
4608 finalize_literal_type_property (tree t)
4609 {
4610   tree fn;
4611
4612   if (cxx_dialect < cxx0x
4613       || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
4614     CLASSTYPE_LITERAL_P (t) = false;
4615   else if (CLASSTYPE_LITERAL_P (t) && !TYPE_HAS_TRIVIAL_DFLT (t)
4616            && CLASSTYPE_NON_AGGREGATE (t)
4617            && !TYPE_HAS_CONSTEXPR_CTOR (t))
4618     CLASSTYPE_LITERAL_P (t) = false;
4619
4620   if (!CLASSTYPE_LITERAL_P (t))
4621     for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
4622       if (DECL_DECLARED_CONSTEXPR_P (fn)
4623           && TREE_CODE (fn) != TEMPLATE_DECL
4624           && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
4625           && !DECL_CONSTRUCTOR_P (fn))
4626         {
4627           DECL_DECLARED_CONSTEXPR_P (fn) = false;
4628           if (!DECL_GENERATED_P (fn))
4629             {
4630               error ("enclosing class of constexpr non-static member "
4631                      "function %q+#D is not a literal type", fn);
4632               explain_non_literal_class (t);
4633             }
4634         }
4635 }
4636
4637 /* T is a non-literal type used in a context which requires a constant
4638    expression.  Explain why it isn't literal.  */
4639
4640 void
4641 explain_non_literal_class (tree t)
4642 {
4643   static struct pointer_set_t *diagnosed;
4644
4645   if (!CLASS_TYPE_P (t))
4646     return;
4647   t = TYPE_MAIN_VARIANT (t);
4648
4649   if (diagnosed == NULL)
4650     diagnosed = pointer_set_create ();
4651   if (pointer_set_insert (diagnosed, t) != 0)
4652     /* Already explained.  */
4653     return;
4654
4655   inform (0, "%q+T is not literal because:", t);
4656   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
4657     inform (0, "  %q+T has a non-trivial destructor", t);
4658   else if (CLASSTYPE_NON_AGGREGATE (t)
4659            && !TYPE_HAS_TRIVIAL_DFLT (t)
4660            && !TYPE_HAS_CONSTEXPR_CTOR (t))
4661     {
4662       inform (0, "  %q+T is not an aggregate, does not have a trivial "
4663               "default constructor, and has no constexpr constructor that "
4664               "is not a copy or move constructor", t);
4665       if (TYPE_HAS_DEFAULT_CONSTRUCTOR (t)
4666           && !type_has_user_provided_default_constructor (t))
4667         explain_invalid_constexpr_fn (locate_ctor (t));
4668     }
4669   else
4670     {
4671       tree binfo, base_binfo, field; int i;
4672       for (binfo = TYPE_BINFO (t), i = 0;
4673            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4674         {
4675           tree basetype = TREE_TYPE (base_binfo);
4676           if (!CLASSTYPE_LITERAL_P (basetype))
4677             {
4678               inform (0, "  base class %qT of %q+T is non-literal",
4679                       basetype, t);
4680               explain_non_literal_class (basetype);
4681               return;
4682             }
4683         }
4684       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4685         {
4686           tree ftype;
4687           if (TREE_CODE (field) != FIELD_DECL)
4688             continue;
4689           ftype = TREE_TYPE (field);
4690           if (!literal_type_p (ftype))
4691             {
4692               inform (0, "  non-static data member %q+D has "
4693                       "non-literal type", field);
4694               if (CLASS_TYPE_P (ftype))
4695                 explain_non_literal_class (ftype);
4696             }
4697         }
4698     }
4699 }
4700
4701 /* Check the validity of the bases and members declared in T.  Add any
4702    implicitly-generated functions (like copy-constructors and
4703    assignment operators).  Compute various flag bits (like
4704    CLASSTYPE_NON_LAYOUT_POD_T) for T.  This routine works purely at the C++
4705    level: i.e., independently of the ABI in use.  */
4706
4707 static void
4708 check_bases_and_members (tree t)
4709 {
4710   /* Nonzero if the implicitly generated copy constructor should take
4711      a non-const reference argument.  */
4712   int cant_have_const_ctor;
4713   /* Nonzero if the implicitly generated assignment operator
4714      should take a non-const reference argument.  */
4715   int no_const_asn_ref;
4716   tree access_decls;
4717   bool saved_complex_asn_ref;
4718   bool saved_nontrivial_dtor;
4719   tree fn;
4720
4721   /* By default, we use const reference arguments and generate default
4722      constructors.  */
4723   cant_have_const_ctor = 0;
4724   no_const_asn_ref = 0;
4725
4726   /* Check all the base-classes.  */
4727   check_bases (t, &cant_have_const_ctor,
4728                &no_const_asn_ref);
4729
4730   /* Check all the method declarations.  */
4731   check_methods (t);
4732
4733   /* Save the initial values of these flags which only indicate whether
4734      or not the class has user-provided functions.  As we analyze the
4735      bases and members we can set these flags for other reasons.  */
4736   saved_complex_asn_ref = TYPE_HAS_COMPLEX_COPY_ASSIGN (t);
4737   saved_nontrivial_dtor = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
4738
4739   /* Check all the data member declarations.  We cannot call
4740      check_field_decls until we have called check_bases check_methods,
4741      as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4742      being set appropriately.  */
4743   check_field_decls (t, &access_decls,
4744                      &cant_have_const_ctor,
4745                      &no_const_asn_ref);
4746
4747   /* A nearly-empty class has to be vptr-containing; a nearly empty
4748      class contains just a vptr.  */
4749   if (!TYPE_CONTAINS_VPTR_P (t))
4750     CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4751
4752   /* Do some bookkeeping that will guide the generation of implicitly
4753      declared member functions.  */
4754   TYPE_HAS_COMPLEX_COPY_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t);
4755   TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t);
4756   /* We need to call a constructor for this class if it has a
4757      user-provided constructor, or if the default constructor is going
4758      to initialize the vptr.  (This is not an if-and-only-if;
4759      TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
4760      themselves need constructing.)  */
4761   TYPE_NEEDS_CONSTRUCTING (t)
4762     |= (type_has_user_provided_constructor (t) || TYPE_CONTAINS_VPTR_P (t));
4763   /* [dcl.init.aggr]
4764
4765      An aggregate is an array or a class with no user-provided
4766      constructors ... and no virtual functions.
4767
4768      Again, other conditions for being an aggregate are checked
4769      elsewhere.  */
4770   CLASSTYPE_NON_AGGREGATE (t)
4771     |= (type_has_user_provided_constructor (t) || TYPE_POLYMORPHIC_P (t));
4772   /* This is the C++98/03 definition of POD; it changed in C++0x, but we
4773      retain the old definition internally for ABI reasons.  */
4774   CLASSTYPE_NON_LAYOUT_POD_P (t)
4775     |= (CLASSTYPE_NON_AGGREGATE (t)
4776         || saved_nontrivial_dtor || saved_complex_asn_ref);
4777   CLASSTYPE_NON_STD_LAYOUT (t) |= TYPE_CONTAINS_VPTR_P (t);
4778   TYPE_HAS_COMPLEX_COPY_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t);
4779   TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t);
4780   TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_CONTAINS_VPTR_P (t);
4781
4782   /* If the class has no user-declared constructor, but does have
4783      non-static const or reference data members that can never be
4784      initialized, issue a warning.  */
4785   if (warn_uninitialized
4786       /* Classes with user-declared constructors are presumed to
4787          initialize these members.  */
4788       && !TYPE_HAS_USER_CONSTRUCTOR (t)
4789       /* Aggregates can be initialized with brace-enclosed
4790          initializers.  */
4791       && CLASSTYPE_NON_AGGREGATE (t))
4792     {
4793       tree field;
4794
4795       for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4796         {
4797           tree type;
4798
4799           if (TREE_CODE (field) != FIELD_DECL)
4800             continue;
4801
4802           type = TREE_TYPE (field);
4803           if (TREE_CODE (type) == REFERENCE_TYPE)
4804             warning (OPT_Wuninitialized, "non-static reference %q+#D "
4805                      "in class without a constructor", field);
4806           else if (CP_TYPE_CONST_P (type)
4807                    && (!CLASS_TYPE_P (type)
4808                        || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4809             warning (OPT_Wuninitialized, "non-static const member %q+#D "
4810                      "in class without a constructor", field);
4811         }
4812     }
4813
4814   /* Synthesize any needed methods.  */
4815   add_implicitly_declared_members (t,
4816                                    cant_have_const_ctor,
4817                                    no_const_asn_ref);
4818
4819   /* Check defaulted declarations here so we have cant_have_const_ctor
4820      and don't need to worry about clones.  */
4821   for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
4822     if (DECL_DEFAULTED_IN_CLASS_P (fn))
4823       {
4824         int copy = copy_fn_p (fn);
4825         if (copy > 0)
4826           {
4827             bool imp_const_p
4828               = (DECL_CONSTRUCTOR_P (fn) ? !cant_have_const_ctor
4829                  : !no_const_asn_ref);
4830             bool fn_const_p = (copy == 2);
4831
4832             if (fn_const_p && !imp_const_p)
4833               /* If the function is defaulted outside the class, we just
4834                  give the synthesis error.  */
4835               error ("%q+D declared to take const reference, but implicit "
4836                      "declaration would take non-const", fn);
4837             else if (imp_const_p && !fn_const_p)
4838               error ("%q+D declared to take non-const reference cannot be "
4839                      "defaulted in the class body", fn);
4840           }
4841         defaulted_late_check (fn);
4842       }
4843
4844   if (LAMBDA_TYPE_P (t))
4845     {
4846       /* "The closure type associated with a lambda-expression has a deleted
4847          default constructor and a deleted copy assignment operator."  */
4848       TYPE_NEEDS_CONSTRUCTING (t) = 1;
4849       TYPE_HAS_COMPLEX_DFLT (t) = 1;
4850       TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1;
4851       CLASSTYPE_LAZY_MOVE_ASSIGN (t) = 0;
4852
4853       /* "This class type is not an aggregate."  */
4854       CLASSTYPE_NON_AGGREGATE (t) = 1;
4855     }
4856
4857   /* Compute the 'literal type' property before we
4858      do anything with non-static member functions.  */
4859   finalize_literal_type_property (t);
4860
4861   /* Create the in-charge and not-in-charge variants of constructors
4862      and destructors.  */
4863   clone_constructors_and_destructors (t);
4864
4865   /* Process the using-declarations.  */
4866   for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4867     handle_using_decl (TREE_VALUE (access_decls), t);
4868
4869   /* Build and sort the CLASSTYPE_METHOD_VEC.  */
4870   finish_struct_methods (t);
4871
4872   /* Figure out whether or not we will need a cookie when dynamically
4873      allocating an array of this type.  */
4874   TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4875     = type_requires_array_cookie (t);
4876 }
4877
4878 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4879    accordingly.  If a new vfield was created (because T doesn't have a
4880    primary base class), then the newly created field is returned.  It
4881    is not added to the TYPE_FIELDS list; it is the caller's
4882    responsibility to do that.  Accumulate declared virtual functions
4883    on VIRTUALS_P.  */
4884
4885 static tree
4886 create_vtable_ptr (tree t, tree* virtuals_p)
4887 {
4888   tree fn;
4889
4890   /* Collect the virtual functions declared in T.  */
4891   for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
4892     if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4893         && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4894       {
4895         tree new_virtual = make_node (TREE_LIST);
4896
4897         BV_FN (new_virtual) = fn;
4898         BV_DELTA (new_virtual) = integer_zero_node;
4899         BV_VCALL_INDEX (new_virtual) = NULL_TREE;
4900
4901         TREE_CHAIN (new_virtual) = *virtuals_p;
4902         *virtuals_p = new_virtual;
4903       }
4904
4905   /* If we couldn't find an appropriate base class, create a new field
4906      here.  Even if there weren't any new virtual functions, we might need a
4907      new virtual function table if we're supposed to include vptrs in
4908      all classes that need them.  */
4909   if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4910     {
4911       /* We build this decl with vtbl_ptr_type_node, which is a
4912          `vtable_entry_type*'.  It might seem more precise to use
4913          `vtable_entry_type (*)[N]' where N is the number of virtual
4914          functions.  However, that would require the vtable pointer in
4915          base classes to have a different type than the vtable pointer
4916          in derived classes.  We could make that happen, but that
4917          still wouldn't solve all the problems.  In particular, the
4918          type-based alias analysis code would decide that assignments
4919          to the base class vtable pointer can't alias assignments to
4920          the derived class vtable pointer, since they have different
4921          types.  Thus, in a derived class destructor, where the base
4922          class constructor was inlined, we could generate bad code for
4923          setting up the vtable pointer.
4924
4925          Therefore, we use one type for all vtable pointers.  We still
4926          use a type-correct type; it's just doesn't indicate the array
4927          bounds.  That's better than using `void*' or some such; it's
4928          cleaner, and it let's the alias analysis code know that these
4929          stores cannot alias stores to void*!  */
4930       tree field;
4931
4932       field = build_decl (input_location,
4933                           FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4934       DECL_VIRTUAL_P (field) = 1;
4935       DECL_ARTIFICIAL (field) = 1;
4936       DECL_FIELD_CONTEXT (field) = t;
4937       DECL_FCONTEXT (field) = t;
4938       if (TYPE_PACKED (t))
4939         DECL_PACKED (field) = 1;
4940
4941       TYPE_VFIELD (t) = field;
4942
4943       /* This class is non-empty.  */
4944       CLASSTYPE_EMPTY_P (t) = 0;
4945
4946       return field;
4947     }
4948
4949   return NULL_TREE;
4950 }
4951
4952 /* Add OFFSET to all base types of BINFO which is a base in the
4953    hierarchy dominated by T.
4954
4955    OFFSET, which is a type offset, is number of bytes.  */
4956
4957 static void
4958 propagate_binfo_offsets (tree binfo, tree offset)
4959 {
4960   int i;
4961   tree primary_binfo;
4962   tree base_binfo;
4963
4964   /* Update BINFO's offset.  */
4965   BINFO_OFFSET (binfo)
4966     = convert (sizetype,
4967                size_binop (PLUS_EXPR,
4968                            convert (ssizetype, BINFO_OFFSET (binfo)),
4969                            offset));
4970
4971   /* Find the primary base class.  */
4972   primary_binfo = get_primary_binfo (binfo);
4973
4974   if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo)
4975     propagate_binfo_offsets (primary_binfo, offset);
4976
4977   /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4978      downwards.  */
4979   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4980     {
4981       /* Don't do the primary base twice.  */
4982       if (base_binfo == primary_binfo)
4983         continue;
4984
4985       if (BINFO_VIRTUAL_P (base_binfo))
4986         continue;
4987
4988       propagate_binfo_offsets (base_binfo, offset);
4989     }
4990 }
4991
4992 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T.  Update
4993    TYPE_ALIGN and TYPE_SIZE for T.  OFFSETS gives the location of
4994    empty subobjects of T.  */
4995
4996 static void
4997 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4998 {
4999   tree vbase;
5000   tree t = rli->t;
5001   bool first_vbase = true;
5002   tree *next_field;
5003
5004   if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0)
5005     return;
5006
5007   if (!abi_version_at_least(2))
5008     {
5009       /* In G++ 3.2, we incorrectly rounded the size before laying out
5010          the virtual bases.  */
5011       finish_record_layout (rli, /*free_p=*/false);
5012 #ifdef STRUCTURE_SIZE_BOUNDARY
5013       /* Packed structures don't need to have minimum size.  */
5014       if (! TYPE_PACKED (t))
5015         TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
5016 #endif
5017       rli->offset = TYPE_SIZE_UNIT (t);
5018       rli->bitpos = bitsize_zero_node;
5019       rli->record_align = TYPE_ALIGN (t);
5020     }
5021
5022   /* Find the last field.  The artificial fields created for virtual
5023      bases will go after the last extant field to date.  */
5024   next_field = &TYPE_FIELDS (t);
5025   while (*next_field)
5026     next_field = &DECL_CHAIN (*next_field);
5027
5028   /* Go through the virtual bases, allocating space for each virtual
5029      base that is not already a primary base class.  These are
5030      allocated in inheritance graph order.  */
5031   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
5032     {
5033       if (!BINFO_VIRTUAL_P (vbase))
5034         continue;
5035
5036       if (!BINFO_PRIMARY_P (vbase))
5037         {
5038           tree basetype = TREE_TYPE (vbase);
5039
5040           /* This virtual base is not a primary base of any class in the
5041              hierarchy, so we have to add space for it.  */
5042           next_field = build_base_field (rli, vbase,
5043                                          offsets, next_field);
5044
5045           /* If the first virtual base might have been placed at a
5046              lower address, had we started from CLASSTYPE_SIZE, rather
5047              than TYPE_SIZE, issue a warning.  There can be both false
5048              positives and false negatives from this warning in rare
5049              cases; to deal with all the possibilities would probably
5050              require performing both layout algorithms and comparing
5051              the results which is not particularly tractable.  */
5052           if (warn_abi
5053               && first_vbase
5054               && (tree_int_cst_lt
5055                   (size_binop (CEIL_DIV_EXPR,
5056                                round_up_loc (input_location,
5057                                          CLASSTYPE_SIZE (t),
5058                                          CLASSTYPE_ALIGN (basetype)),
5059                                bitsize_unit_node),
5060                    BINFO_OFFSET (vbase))))
5061             warning (OPT_Wabi,
5062                      "offset of virtual base %qT is not ABI-compliant and "
5063                      "may change in a future version of GCC",
5064                      basetype);
5065
5066           first_vbase = false;
5067         }
5068     }
5069 }
5070
5071 /* Returns the offset of the byte just past the end of the base class
5072    BINFO.  */
5073
5074 static tree
5075 end_of_base (tree binfo)
5076 {
5077   tree size;
5078
5079   if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo)))
5080     size = TYPE_SIZE_UNIT (char_type_node);
5081   else if (is_empty_class (BINFO_TYPE (binfo)))
5082     /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5083        allocate some space for it. It cannot have virtual bases, so
5084        TYPE_SIZE_UNIT is fine.  */
5085     size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
5086   else
5087     size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
5088
5089   return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
5090 }
5091
5092 /* Returns the offset of the byte just past the end of the base class
5093    with the highest offset in T.  If INCLUDE_VIRTUALS_P is zero, then
5094    only non-virtual bases are included.  */
5095
5096 static tree
5097 end_of_class (tree t, int include_virtuals_p)
5098 {
5099   tree result = size_zero_node;
5100   VEC(tree,gc) *vbases;
5101   tree binfo;
5102   tree base_binfo;
5103   tree offset;
5104   int i;
5105
5106   for (binfo = TYPE_BINFO (t), i = 0;
5107        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
5108     {
5109       if (!include_virtuals_p
5110           && BINFO_VIRTUAL_P (base_binfo)
5111           && (!BINFO_PRIMARY_P (base_binfo)
5112               || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t)))
5113         continue;
5114
5115       offset = end_of_base (base_binfo);
5116       if (INT_CST_LT_UNSIGNED (result, offset))
5117         result = offset;
5118     }
5119
5120   /* G++ 3.2 did not check indirect virtual bases.  */
5121   if (abi_version_at_least (2) && include_virtuals_p)
5122     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
5123          VEC_iterate (tree, vbases, i, base_binfo); i++)
5124       {
5125         offset = end_of_base (base_binfo);
5126         if (INT_CST_LT_UNSIGNED (result, offset))
5127           result = offset;
5128       }
5129
5130   return result;
5131 }
5132
5133 /* Warn about bases of T that are inaccessible because they are
5134    ambiguous.  For example:
5135
5136      struct S {};
5137      struct T : public S {};
5138      struct U : public S, public T {};
5139
5140    Here, `(S*) new U' is not allowed because there are two `S'
5141    subobjects of U.  */
5142
5143 static void
5144 warn_about_ambiguous_bases (tree t)
5145 {
5146   int i;
5147   VEC(tree,gc) *vbases;
5148   tree basetype;
5149   tree binfo;
5150   tree base_binfo;
5151
5152   /* If there are no repeated bases, nothing can be ambiguous.  */
5153   if (!CLASSTYPE_REPEATED_BASE_P (t))
5154     return;
5155
5156   /* Check direct bases.  */
5157   for (binfo = TYPE_BINFO (t), i = 0;
5158        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
5159     {
5160       basetype = BINFO_TYPE (base_binfo);
5161
5162       if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
5163         warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
5164                  basetype, t);
5165     }
5166
5167   /* Check for ambiguous virtual bases.  */
5168   if (extra_warnings)
5169     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
5170          VEC_iterate (tree, vbases, i, binfo); i++)
5171       {
5172         basetype = BINFO_TYPE (binfo);
5173
5174         if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
5175           warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due to ambiguity",
5176                    basetype, t);
5177       }
5178 }
5179
5180 /* Compare two INTEGER_CSTs K1 and K2.  */
5181
5182 static int
5183 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
5184 {
5185   return tree_int_cst_compare ((tree) k1, (tree) k2);
5186 }
5187
5188 /* Increase the size indicated in RLI to account for empty classes
5189    that are "off the end" of the class.  */
5190
5191 static void
5192 include_empty_classes (record_layout_info rli)
5193 {
5194   tree eoc;
5195   tree rli_size;
5196
5197   /* It might be the case that we grew the class to allocate a
5198      zero-sized base class.  That won't be reflected in RLI, yet,
5199      because we are willing to overlay multiple bases at the same
5200      offset.  However, now we need to make sure that RLI is big enough
5201      to reflect the entire class.  */
5202   eoc = end_of_class (rli->t,
5203                       CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
5204   rli_size = rli_size_unit_so_far (rli);
5205   if (TREE_CODE (rli_size) == INTEGER_CST
5206       && INT_CST_LT_UNSIGNED (rli_size, eoc))
5207     {
5208       if (!abi_version_at_least (2))
5209         /* In version 1 of the ABI, the size of a class that ends with
5210            a bitfield was not rounded up to a whole multiple of a
5211            byte.  Because rli_size_unit_so_far returns only the number
5212            of fully allocated bytes, any extra bits were not included
5213            in the size.  */
5214         rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
5215       else
5216         /* The size should have been rounded to a whole byte.  */
5217         gcc_assert (tree_int_cst_equal
5218                     (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT)));
5219       rli->bitpos
5220         = size_binop (PLUS_EXPR,
5221                       rli->bitpos,
5222                       size_binop (MULT_EXPR,
5223                                   convert (bitsizetype,
5224                                            size_binop (MINUS_EXPR,
5225                                                        eoc, rli_size)),
5226                                   bitsize_int (BITS_PER_UNIT)));
5227       normalize_rli (rli);
5228     }
5229 }
5230
5231 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T.  Calculate
5232    BINFO_OFFSETs for all of the base-classes.  Position the vtable
5233    pointer.  Accumulate declared virtual functions on VIRTUALS_P.  */
5234
5235 static void
5236 layout_class_type (tree t, tree *virtuals_p)
5237 {
5238   tree non_static_data_members;
5239   tree field;
5240   tree vptr;
5241   record_layout_info rli;
5242   /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5243      types that appear at that offset.  */
5244   splay_tree empty_base_offsets;
5245   /* True if the last field layed out was a bit-field.  */
5246   bool last_field_was_bitfield = false;
5247   /* The location at which the next field should be inserted.  */
5248   tree *next_field;
5249   /* T, as a base class.  */
5250   tree base_t;
5251
5252   /* Keep track of the first non-static data member.  */
5253   non_static_data_members = TYPE_FIELDS (t);
5254
5255   /* Start laying out the record.  */
5256   rli = start_record_layout (t);
5257
5258   /* Mark all the primary bases in the hierarchy.  */
5259   determine_primary_bases (t);
5260
5261   /* Create a pointer to our virtual function table.  */
5262   vptr = create_vtable_ptr (t, virtuals_p);
5263
5264   /* The vptr is always the first thing in the class.  */
5265   if (vptr)
5266     {
5267       DECL_CHAIN (vptr) = TYPE_FIELDS (t);
5268       TYPE_FIELDS (t) = vptr;
5269       next_field = &DECL_CHAIN (vptr);
5270       place_field (rli, vptr);
5271     }
5272   else
5273     next_field = &TYPE_FIELDS (t);
5274
5275   /* Build FIELD_DECLs for all of the non-virtual base-types.  */
5276   empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
5277                                        NULL, NULL);
5278   build_base_fields (rli, empty_base_offsets, next_field);
5279
5280   /* Layout the non-static data members.  */
5281   for (field = non_static_data_members; field; field = DECL_CHAIN (field))
5282     {
5283       tree type;
5284       tree padding;
5285
5286       /* We still pass things that aren't non-static data members to
5287          the back end, in case it wants to do something with them.  */
5288       if (TREE_CODE (field) != FIELD_DECL)
5289         {
5290           place_field (rli, field);
5291           /* If the static data member has incomplete type, keep track
5292              of it so that it can be completed later.  (The handling
5293              of pending statics in finish_record_layout is
5294              insufficient; consider:
5295
5296                struct S1;
5297                struct S2 { static S1 s1; };
5298
5299              At this point, finish_record_layout will be called, but
5300              S1 is still incomplete.)  */
5301           if (TREE_CODE (field) == VAR_DECL)
5302             {
5303               maybe_register_incomplete_var (field);
5304               /* The visibility of static data members is determined
5305                  at their point of declaration, not their point of
5306                  definition.  */
5307               determine_visibility (field);
5308             }
5309           continue;
5310         }
5311
5312       type = TREE_TYPE (field);
5313       if (type == error_mark_node)
5314         continue;
5315
5316       padding = NULL_TREE;
5317
5318       /* If this field is a bit-field whose width is greater than its
5319          type, then there are some special rules for allocating
5320          it.  */
5321       if (DECL_C_BIT_FIELD (field)
5322           && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
5323         {
5324           unsigned int itk;
5325           tree integer_type;
5326           bool was_unnamed_p = false;
5327           /* We must allocate the bits as if suitably aligned for the
5328              longest integer type that fits in this many bits.  type
5329              of the field.  Then, we are supposed to use the left over
5330              bits as additional padding.  */
5331           for (itk = itk_char; itk != itk_none; ++itk)
5332             if (integer_types[itk] != NULL_TREE
5333                 && (INT_CST_LT (size_int (MAX_FIXED_MODE_SIZE),
5334                                 TYPE_SIZE (integer_types[itk]))
5335                     || INT_CST_LT (DECL_SIZE (field),
5336                                    TYPE_SIZE (integer_types[itk]))))
5337               break;
5338
5339           /* ITK now indicates a type that is too large for the
5340              field.  We have to back up by one to find the largest
5341              type that fits.  */
5342           do
5343           {
5344             --itk;
5345             integer_type = integer_types[itk];
5346           } while (itk > 0 && integer_type == NULL_TREE);
5347
5348           /* Figure out how much additional padding is required.  GCC
5349              3.2 always created a padding field, even if it had zero
5350              width.  */
5351           if (!abi_version_at_least (2)
5352               || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
5353             {
5354               if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
5355                 /* In a union, the padding field must have the full width
5356                    of the bit-field; all fields start at offset zero.  */
5357                 padding = DECL_SIZE (field);
5358               else
5359                 {
5360                   if (TREE_CODE (t) == UNION_TYPE)
5361                     warning (OPT_Wabi, "size assigned to %qT may not be "
5362                              "ABI-compliant and may change in a future "
5363                              "version of GCC",
5364                              t);
5365                   padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
5366                                         TYPE_SIZE (integer_type));
5367                 }
5368             }
5369 #ifdef PCC_BITFIELD_TYPE_MATTERS
5370           /* An unnamed bitfield does not normally affect the
5371              alignment of the containing class on a target where
5372              PCC_BITFIELD_TYPE_MATTERS.  But, the C++ ABI does not
5373              make any exceptions for unnamed bitfields when the
5374              bitfields are longer than their types.  Therefore, we
5375              temporarily give the field a name.  */
5376           if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
5377             {
5378               was_unnamed_p = true;
5379               DECL_NAME (field) = make_anon_name ();
5380             }
5381 #endif
5382           DECL_SIZE (field) = TYPE_SIZE (integer_type);
5383           DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
5384           DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
5385           layout_nonempty_base_or_field (rli, field, NULL_TREE,
5386                                          empty_base_offsets);
5387           if (was_unnamed_p)
5388             DECL_NAME (field) = NULL_TREE;
5389           /* Now that layout has been performed, set the size of the
5390              field to the size of its declared type; the rest of the
5391              field is effectively invisible.  */
5392           DECL_SIZE (field) = TYPE_SIZE (type);
5393           /* We must also reset the DECL_MODE of the field.  */
5394           if (abi_version_at_least (2))
5395             DECL_MODE (field) = TYPE_MODE (type);
5396           else if (warn_abi
5397                    && DECL_MODE (field) != TYPE_MODE (type))
5398             /* Versions of G++ before G++ 3.4 did not reset the
5399                DECL_MODE.  */
5400             warning (OPT_Wabi,
5401                      "the offset of %qD may not be ABI-compliant and may "
5402                      "change in a future version of GCC", field);
5403         }
5404       else
5405         layout_nonempty_base_or_field (rli, field, NULL_TREE,
5406                                        empty_base_offsets);
5407
5408       /* Remember the location of any empty classes in FIELD.  */
5409       if (abi_version_at_least (2))
5410         record_subobject_offsets (TREE_TYPE (field),
5411                                   byte_position(field),
5412                                   empty_base_offsets,
5413                                   /*is_data_member=*/true);
5414
5415       /* If a bit-field does not immediately follow another bit-field,
5416          and yet it starts in the middle of a byte, we have failed to
5417          comply with the ABI.  */
5418       if (warn_abi
5419           && DECL_C_BIT_FIELD (field)
5420           /* The TREE_NO_WARNING flag gets set by Objective-C when
5421              laying out an Objective-C class.  The ObjC ABI differs
5422              from the C++ ABI, and so we do not want a warning
5423              here.  */
5424           && !TREE_NO_WARNING (field)
5425           && !last_field_was_bitfield
5426           && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
5427                                          DECL_FIELD_BIT_OFFSET (field),
5428                                          bitsize_unit_node)))
5429         warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may "
5430                  "change in a future version of GCC", field);
5431
5432       /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
5433          offset of the field.  */
5434       if (warn_abi
5435           && !abi_version_at_least (2)
5436           && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
5437                                   byte_position (field))
5438           && contains_empty_class_p (TREE_TYPE (field)))
5439         warning (OPT_Wabi, "%q+D contains empty classes which may cause base "
5440                  "classes to be placed at different locations in a "
5441                  "future version of GCC", field);
5442
5443       /* The middle end uses the type of expressions to determine the
5444          possible range of expression values.  In order to optimize
5445          "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
5446          must be made aware of the width of "i", via its type.
5447
5448          Because C++ does not have integer types of arbitrary width,
5449          we must (for the purposes of the front end) convert from the
5450          type assigned here to the declared type of the bitfield
5451          whenever a bitfield expression is used as an rvalue.
5452          Similarly, when assigning a value to a bitfield, the value
5453          must be converted to the type given the bitfield here.  */
5454       if (DECL_C_BIT_FIELD (field))
5455         {
5456           unsigned HOST_WIDE_INT width;
5457           tree ftype = TREE_TYPE (field);
5458           width = tree_low_cst (DECL_SIZE (field), /*unsignedp=*/1);
5459           if (width != TYPE_PRECISION (ftype))
5460             {
5461               TREE_TYPE (field)
5462                 = c_build_bitfield_integer_type (width,
5463                                                  TYPE_UNSIGNED (ftype));
5464               TREE_TYPE (field)
5465                 = cp_build_qualified_type (TREE_TYPE (field),
5466                                            cp_type_quals (ftype));
5467             }
5468         }
5469
5470       /* If we needed additional padding after this field, add it
5471          now.  */
5472       if (padding)
5473         {
5474           tree padding_field;
5475
5476           padding_field = build_decl (input_location,
5477                                       FIELD_DECL,
5478                                       NULL_TREE,
5479                                       char_type_node);
5480           DECL_BIT_FIELD (padding_field) = 1;
5481           DECL_SIZE (padding_field) = padding;
5482           DECL_CONTEXT (padding_field) = t;
5483           DECL_ARTIFICIAL (padding_field) = 1;
5484           DECL_IGNORED_P (padding_field) = 1;
5485           layout_nonempty_base_or_field (rli, padding_field,
5486                                          NULL_TREE,
5487                                          empty_base_offsets);
5488         }
5489
5490       last_field_was_bitfield = DECL_C_BIT_FIELD (field);
5491     }
5492
5493   if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
5494     {
5495       /* Make sure that we are on a byte boundary so that the size of
5496          the class without virtual bases will always be a round number
5497          of bytes.  */
5498       rli->bitpos = round_up_loc (input_location, rli->bitpos, BITS_PER_UNIT);
5499       normalize_rli (rli);
5500     }
5501
5502   /* G++ 3.2 does not allow virtual bases to be overlaid with tail
5503      padding.  */
5504   if (!abi_version_at_least (2))
5505     include_empty_classes(rli);
5506
5507   /* Delete all zero-width bit-fields from the list of fields.  Now
5508      that the type is laid out they are no longer important.  */
5509   remove_zero_width_bit_fields (t);
5510
5511   /* Create the version of T used for virtual bases.  We do not use
5512      make_class_type for this version; this is an artificial type.  For
5513      a POD type, we just reuse T.  */
5514   if (CLASSTYPE_NON_LAYOUT_POD_P (t) || CLASSTYPE_EMPTY_P (t))
5515     {
5516       base_t = make_node (TREE_CODE (t));
5517
5518       /* Set the size and alignment for the new type.  In G++ 3.2, all
5519          empty classes were considered to have size zero when used as
5520          base classes.  */
5521       if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
5522         {
5523           TYPE_SIZE (base_t) = bitsize_zero_node;
5524           TYPE_SIZE_UNIT (base_t) = size_zero_node;
5525           if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
5526             warning (OPT_Wabi,
5527                      "layout of classes derived from empty class %qT "
5528                      "may change in a future version of GCC",
5529                      t);
5530         }
5531       else
5532         {
5533           tree eoc;
5534
5535           /* If the ABI version is not at least two, and the last
5536              field was a bit-field, RLI may not be on a byte
5537              boundary.  In particular, rli_size_unit_so_far might
5538              indicate the last complete byte, while rli_size_so_far
5539              indicates the total number of bits used.  Therefore,
5540              rli_size_so_far, rather than rli_size_unit_so_far, is
5541              used to compute TYPE_SIZE_UNIT.  */
5542           eoc = end_of_class (t, /*include_virtuals_p=*/0);
5543           TYPE_SIZE_UNIT (base_t)
5544             = size_binop (MAX_EXPR,
5545                           convert (sizetype,
5546                                    size_binop (CEIL_DIV_EXPR,
5547                                                rli_size_so_far (rli),
5548                                                bitsize_int (BITS_PER_UNIT))),
5549                           eoc);
5550           TYPE_SIZE (base_t)
5551             = size_binop (MAX_EXPR,
5552                           rli_size_so_far (rli),
5553                           size_binop (MULT_EXPR,
5554                                       convert (bitsizetype, eoc),
5555                                       bitsize_int (BITS_PER_UNIT)));
5556         }
5557       TYPE_ALIGN (base_t) = rli->record_align;
5558       TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
5559
5560       /* Copy the fields from T.  */
5561       next_field = &TYPE_FIELDS (base_t);
5562       for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
5563         if (TREE_CODE (field) == FIELD_DECL)
5564           {
5565             *next_field = build_decl (input_location,
5566                                       FIELD_DECL,
5567                                       DECL_NAME (field),
5568                                       TREE_TYPE (field));
5569             DECL_CONTEXT (*next_field) = base_t;
5570             DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
5571             DECL_FIELD_BIT_OFFSET (*next_field)
5572               = DECL_FIELD_BIT_OFFSET (field);
5573             DECL_SIZE (*next_field) = DECL_SIZE (field);
5574             DECL_MODE (*next_field) = DECL_MODE (field);
5575             next_field = &DECL_CHAIN (*next_field);
5576           }
5577
5578       /* Record the base version of the type.  */
5579       CLASSTYPE_AS_BASE (t) = base_t;
5580       TYPE_CONTEXT (base_t) = t;
5581     }
5582   else
5583     CLASSTYPE_AS_BASE (t) = t;
5584
5585   /* Every empty class contains an empty class.  */
5586   if (CLASSTYPE_EMPTY_P (t))
5587     CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
5588
5589   /* Set the TYPE_DECL for this type to contain the right
5590      value for DECL_OFFSET, so that we can use it as part
5591      of a COMPONENT_REF for multiple inheritance.  */
5592   layout_decl (TYPE_MAIN_DECL (t), 0);
5593
5594   /* Now fix up any virtual base class types that we left lying
5595      around.  We must get these done before we try to lay out the
5596      virtual function table.  As a side-effect, this will remove the
5597      base subobject fields.  */
5598   layout_virtual_bases (rli, empty_base_offsets);
5599
5600   /* Make sure that empty classes are reflected in RLI at this
5601      point.  */
5602   include_empty_classes(rli);
5603
5604   /* Make sure not to create any structures with zero size.  */
5605   if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
5606     place_field (rli,
5607                  build_decl (input_location,
5608                              FIELD_DECL, NULL_TREE, char_type_node));
5609
5610   /* If this is a non-POD, declaring it packed makes a difference to how it
5611      can be used as a field; don't let finalize_record_size undo it.  */
5612   if (TYPE_PACKED (t) && !layout_pod_type_p (t))
5613     rli->packed_maybe_necessary = true;
5614
5615   /* Let the back end lay out the type.  */
5616   finish_record_layout (rli, /*free_p=*/true);
5617
5618   /* Warn about bases that can't be talked about due to ambiguity.  */
5619   warn_about_ambiguous_bases (t);
5620
5621   /* Now that we're done with layout, give the base fields the real types.  */
5622   for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
5623     if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
5624       TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
5625
5626   /* Clean up.  */
5627   splay_tree_delete (empty_base_offsets);
5628
5629   if (CLASSTYPE_EMPTY_P (t)
5630       && tree_int_cst_lt (sizeof_biggest_empty_class,
5631                           TYPE_SIZE_UNIT (t)))
5632     sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
5633 }
5634
5635 /* Determine the "key method" for the class type indicated by TYPE,
5636    and set CLASSTYPE_KEY_METHOD accordingly.  */
5637
5638 void
5639 determine_key_method (tree type)
5640 {
5641   tree method;
5642
5643   if (TYPE_FOR_JAVA (type)
5644       || processing_template_decl
5645       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
5646       || CLASSTYPE_INTERFACE_KNOWN (type))
5647     return;
5648
5649   /* The key method is the first non-pure virtual function that is not
5650      inline at the point of class definition.  On some targets the
5651      key function may not be inline; those targets should not call
5652      this function until the end of the translation unit.  */
5653   for (method = TYPE_METHODS (type); method != NULL_TREE;
5654        method = DECL_CHAIN (method))
5655     if (DECL_VINDEX (method) != NULL_TREE
5656         && ! DECL_DECLARED_INLINE_P (method)
5657         && ! DECL_PURE_VIRTUAL_P (method))
5658       {
5659         CLASSTYPE_KEY_METHOD (type) = method;
5660         break;
5661       }
5662
5663   return;
5664 }
5665
5666 /* Perform processing required when the definition of T (a class type)
5667    is complete.  */
5668
5669 void
5670 finish_struct_1 (tree t)
5671 {
5672   tree x;
5673   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
5674   tree virtuals = NULL_TREE;
5675   int n_fields = 0;
5676
5677   if (COMPLETE_TYPE_P (t))
5678     {
5679       gcc_assert (MAYBE_CLASS_TYPE_P (t));
5680       error ("redefinition of %q#T", t);
5681       popclass ();
5682       return;
5683     }
5684
5685   /* If this type was previously laid out as a forward reference,
5686      make sure we lay it out again.  */
5687   TYPE_SIZE (t) = NULL_TREE;
5688   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5689
5690   /* Make assumptions about the class; we'll reset the flags if
5691      necessary.  */
5692   CLASSTYPE_EMPTY_P (t) = 1;
5693   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5694   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5695   CLASSTYPE_LITERAL_P (t) = true;
5696
5697   /* Do end-of-class semantic processing: checking the validity of the
5698      bases and members and add implicitly generated methods.  */
5699   check_bases_and_members (t);
5700
5701   /* Find the key method.  */
5702   if (TYPE_CONTAINS_VPTR_P (t))
5703     {
5704       /* The Itanium C++ ABI permits the key method to be chosen when
5705          the class is defined -- even though the key method so
5706          selected may later turn out to be an inline function.  On
5707          some systems (such as ARM Symbian OS) the key method cannot
5708          be determined until the end of the translation unit.  On such
5709          systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
5710          will cause the class to be added to KEYED_CLASSES.  Then, in
5711          finish_file we will determine the key method.  */
5712       if (targetm.cxx.key_method_may_be_inline ())
5713         determine_key_method (t);
5714
5715       /* If a polymorphic class has no key method, we may emit the vtable
5716          in every translation unit where the class definition appears.  */
5717       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5718         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5719     }
5720
5721   /* Layout the class itself.  */
5722   layout_class_type (t, &virtuals);
5723   if (CLASSTYPE_AS_BASE (t) != t)
5724     /* We use the base type for trivial assignments, and hence it
5725        needs a mode.  */
5726     compute_record_mode (CLASSTYPE_AS_BASE (t));
5727
5728   virtuals = modify_all_vtables (t, nreverse (virtuals));
5729
5730   /* If necessary, create the primary vtable for this class.  */
5731   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5732     {
5733       /* We must enter these virtuals into the table.  */
5734       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5735         build_primary_vtable (NULL_TREE, t);
5736       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5737         /* Here we know enough to change the type of our virtual
5738            function table, but we will wait until later this function.  */
5739         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5740     }
5741
5742   if (TYPE_CONTAINS_VPTR_P (t))
5743     {
5744       int vindex;
5745       tree fn;
5746
5747       if (BINFO_VTABLE (TYPE_BINFO (t)))
5748         gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
5749       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5750         gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
5751
5752       /* Add entries for virtual functions introduced by this class.  */
5753       BINFO_VIRTUALS (TYPE_BINFO (t))
5754         = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
5755
5756       /* Set DECL_VINDEX for all functions declared in this class.  */
5757       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5758            fn;
5759            fn = TREE_CHAIN (fn),
5760              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5761                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5762         {
5763           tree fndecl = BV_FN (fn);
5764
5765           if (DECL_THUNK_P (fndecl))
5766             /* A thunk. We should never be calling this entry directly
5767                from this vtable -- we'd use the entry for the non
5768                thunk base function.  */
5769             DECL_VINDEX (fndecl) = NULL_TREE;
5770           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5771             DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
5772         }
5773     }
5774
5775   finish_struct_bits (t);
5776
5777   /* Complete the rtl for any static member objects of the type we're
5778      working on.  */
5779   for (x = TYPE_FIELDS (t); x; x = DECL_CHAIN (x))
5780     if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5781         && TREE_TYPE (x) != error_mark_node
5782         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5783       DECL_MODE (x) = TYPE_MODE (t);
5784
5785   /* Done with FIELDS...now decide whether to sort these for
5786      faster lookups later.
5787
5788      We use a small number because most searches fail (succeeding
5789      ultimately as the search bores through the inheritance
5790      hierarchy), and we want this failure to occur quickly.  */
5791
5792   n_fields = count_fields (TYPE_FIELDS (t));
5793   if (n_fields > 7)
5794     {
5795       struct sorted_fields_type *field_vec = ggc_alloc_sorted_fields_type
5796          (sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
5797       field_vec->len = n_fields;
5798       add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5799       qsort (field_vec->elts, n_fields, sizeof (tree),
5800              field_decl_cmp);
5801       CLASSTYPE_SORTED_FIELDS (t) = field_vec;
5802     }
5803
5804   /* Complain if one of the field types requires lower visibility.  */
5805   constrain_class_visibility (t);
5806
5807   /* Make the rtl for any new vtables we have created, and unmark
5808      the base types we marked.  */
5809   finish_vtbls (t);
5810
5811   /* Build the VTT for T.  */
5812   build_vtt (t);
5813
5814   /* This warning does not make sense for Java classes, since they
5815      cannot have destructors.  */
5816   if (!TYPE_FOR_JAVA (t) && warn_nonvdtor && TYPE_POLYMORPHIC_P (t))
5817     {
5818       tree dtor;
5819
5820       dtor = CLASSTYPE_DESTRUCTORS (t);
5821       if (/* An implicitly declared destructor is always public.  And,
5822              if it were virtual, we would have created it by now.  */
5823           !dtor
5824           || (!DECL_VINDEX (dtor)
5825               && (/* public non-virtual */
5826                   (!TREE_PRIVATE (dtor) && !TREE_PROTECTED (dtor))
5827                    || (/* non-public non-virtual with friends */
5828                        (TREE_PRIVATE (dtor) || TREE_PROTECTED (dtor))
5829                         && (CLASSTYPE_FRIEND_CLASSES (t)
5830                         || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))))))
5831         warning (OPT_Wnon_virtual_dtor,
5832                  "%q#T has virtual functions and accessible"
5833                  " non-virtual destructor", t);
5834     }
5835
5836   complete_vars (t);
5837
5838   if (warn_overloaded_virtual)
5839     warn_hidden (t);
5840
5841   /* Class layout, assignment of virtual table slots, etc., is now
5842      complete.  Give the back end a chance to tweak the visibility of
5843      the class or perform any other required target modifications.  */
5844   targetm.cxx.adjust_class_at_definition (t);
5845
5846   maybe_suppress_debug_info (t);
5847
5848   dump_class_hierarchy (t);
5849
5850   /* Finish debugging output for this type.  */
5851   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5852
5853   if (TYPE_TRANSPARENT_AGGR (t))
5854     {
5855       tree field = first_field (t);
5856       if (field == NULL_TREE || error_operand_p (field))
5857         {
5858           error ("type transparent class %qT does not have any fields", t);
5859           TYPE_TRANSPARENT_AGGR (t) = 0;
5860         }
5861       else if (DECL_ARTIFICIAL (field))
5862         {
5863           if (DECL_FIELD_IS_BASE (field))
5864             error ("type transparent class %qT has base classes", t);
5865           else
5866             {
5867               gcc_checking_assert (DECL_VIRTUAL_P (field));
5868               error ("type transparent class %qT has virtual functions", t);
5869             }
5870           TYPE_TRANSPARENT_AGGR (t) = 0;
5871         }
5872     }
5873 }
5874
5875 /* When T was built up, the member declarations were added in reverse
5876    order.  Rearrange them to declaration order.  */
5877
5878 void
5879 unreverse_member_declarations (tree t)
5880 {
5881   tree next;
5882   tree prev;
5883   tree x;
5884
5885   /* The following lists are all in reverse order.  Put them in
5886      declaration order now.  */
5887   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5888   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5889
5890   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5891      reverse order, so we can't just use nreverse.  */
5892   prev = NULL_TREE;
5893   for (x = TYPE_FIELDS (t);
5894        x && TREE_CODE (x) != TYPE_DECL;
5895        x = next)
5896     {
5897       next = DECL_CHAIN (x);
5898       DECL_CHAIN (x) = prev;
5899       prev = x;
5900     }
5901   if (prev)
5902     {
5903       DECL_CHAIN (TYPE_FIELDS (t)) = x;
5904       if (prev)
5905         TYPE_FIELDS (t) = prev;
5906     }
5907 }
5908
5909 tree
5910 finish_struct (tree t, tree attributes)
5911 {
5912   location_t saved_loc = input_location;
5913
5914   /* Now that we've got all the field declarations, reverse everything
5915      as necessary.  */
5916   unreverse_member_declarations (t);
5917
5918   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5919
5920   /* Nadger the current location so that diagnostics point to the start of
5921      the struct, not the end.  */
5922   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5923
5924   if (processing_template_decl)
5925     {
5926       tree x;
5927
5928       finish_struct_methods (t);
5929       TYPE_SIZE (t) = bitsize_zero_node;
5930       TYPE_SIZE_UNIT (t) = size_zero_node;
5931
5932       /* We need to emit an error message if this type was used as a parameter
5933          and it is an abstract type, even if it is a template. We construct
5934          a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5935          account and we call complete_vars with this type, which will check
5936          the PARM_DECLS. Note that while the type is being defined,
5937          CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5938          (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it.  */
5939       CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5940       for (x = TYPE_METHODS (t); x; x = DECL_CHAIN (x))
5941         if (DECL_PURE_VIRTUAL_P (x))
5942           VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
5943       complete_vars (t);
5944
5945       /* Remember current #pragma pack value.  */
5946       TYPE_PRECISION (t) = maximum_field_alignment;
5947     }
5948   else
5949     finish_struct_1 (t);
5950
5951   input_location = saved_loc;
5952
5953   TYPE_BEING_DEFINED (t) = 0;
5954
5955   if (current_class_type)
5956     popclass ();
5957   else
5958     error ("trying to finish struct, but kicked out due to previous parse errors");
5959
5960   if (processing_template_decl && at_function_scope_p ())
5961     add_stmt (build_min (TAG_DEFN, t));
5962
5963   return t;
5964 }
5965 \f
5966 /* Return the dynamic type of INSTANCE, if known.
5967    Used to determine whether the virtual function table is needed
5968    or not.
5969
5970    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5971    of our knowledge of its type.  *NONNULL should be initialized
5972    before this function is called.  */
5973
5974 static tree
5975 fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
5976 {
5977 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
5978
5979   switch (TREE_CODE (instance))
5980     {
5981     case INDIRECT_REF:
5982       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5983         return NULL_TREE;
5984       else
5985         return RECUR (TREE_OPERAND (instance, 0));
5986
5987     case CALL_EXPR:
5988       /* This is a call to a constructor, hence it's never zero.  */
5989       if (TREE_HAS_CONSTRUCTOR (instance))
5990         {
5991           if (nonnull)
5992             *nonnull = 1;
5993           return TREE_TYPE (instance);
5994         }
5995       return NULL_TREE;
5996
5997     case SAVE_EXPR:
5998       /* This is a call to a constructor, hence it's never zero.  */
5999       if (TREE_HAS_CONSTRUCTOR (instance))
6000         {
6001           if (nonnull)
6002             *nonnull = 1;
6003           return TREE_TYPE (instance);
6004         }
6005       return RECUR (TREE_OPERAND (instance, 0));
6006
6007     case POINTER_PLUS_EXPR:
6008     case PLUS_EXPR:
6009     case MINUS_EXPR:
6010       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
6011         return RECUR (TREE_OPERAND (instance, 0));
6012       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
6013         /* Propagate nonnull.  */
6014         return RECUR (TREE_OPERAND (instance, 0));
6015
6016       return NULL_TREE;
6017
6018     CASE_CONVERT:
6019       return RECUR (TREE_OPERAND (instance, 0));
6020
6021     case ADDR_EXPR:
6022       instance = TREE_OPERAND (instance, 0);
6023       if (nonnull)
6024         {
6025           /* Just because we see an ADDR_EXPR doesn't mean we're dealing
6026              with a real object -- given &p->f, p can still be null.  */
6027           tree t = get_base_address (instance);
6028           /* ??? Probably should check DECL_WEAK here.  */
6029           if (t && DECL_P (t))
6030             *nonnull = 1;
6031         }
6032       return RECUR (instance);
6033
6034     case COMPONENT_REF:
6035       /* If this component is really a base class reference, then the field
6036          itself isn't definitive.  */
6037       if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
6038         return RECUR (TREE_OPERAND (instance, 0));
6039       return RECUR (TREE_OPERAND (instance, 1));
6040
6041     case VAR_DECL:
6042     case FIELD_DECL:
6043       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
6044           && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance))))
6045         {
6046           if (nonnull)
6047             *nonnull = 1;
6048           return TREE_TYPE (TREE_TYPE (instance));
6049         }
6050       /* fall through...  */
6051     case TARGET_EXPR:
6052     case PARM_DECL:
6053     case RESULT_DECL:
6054       if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance)))
6055         {
6056           if (nonnull)
6057             *nonnull = 1;
6058           return TREE_TYPE (instance);
6059         }
6060       else if (instance == current_class_ptr)
6061         {
6062           if (nonnull)
6063             *nonnull = 1;
6064
6065           /* if we're in a ctor or dtor, we know our type.  */
6066           if (DECL_LANG_SPECIFIC (current_function_decl)
6067               && (DECL_CONSTRUCTOR_P (current_function_decl)
6068                   || DECL_DESTRUCTOR_P (current_function_decl)))
6069             {
6070               if (cdtorp)
6071                 *cdtorp = 1;
6072               return TREE_TYPE (TREE_TYPE (instance));
6073             }
6074         }
6075       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
6076         {
6077           /* We only need one hash table because it is always left empty.  */
6078           static htab_t ht;
6079           if (!ht)
6080             ht = htab_create (37,
6081                               htab_hash_pointer,
6082                               htab_eq_pointer,
6083                               /*htab_del=*/NULL);
6084
6085           /* Reference variables should be references to objects.  */
6086           if (nonnull)
6087             *nonnull = 1;
6088
6089           /* Enter the INSTANCE in a table to prevent recursion; a
6090              variable's initializer may refer to the variable
6091              itself.  */
6092           if (TREE_CODE (instance) == VAR_DECL
6093               && DECL_INITIAL (instance)
6094               && !type_dependent_expression_p_push (DECL_INITIAL (instance))
6095               && !htab_find (ht, instance))
6096             {
6097               tree type;
6098               void **slot;
6099
6100               slot = htab_find_slot (ht, instance, INSERT);
6101               *slot = instance;
6102               type = RECUR (DECL_INITIAL (instance));
6103               htab_remove_elt (ht, instance);
6104
6105               return type;
6106             }
6107         }
6108       return NULL_TREE;
6109
6110     default:
6111       return NULL_TREE;
6112     }
6113 #undef RECUR
6114 }
6115
6116 /* Return nonzero if the dynamic type of INSTANCE is known, and
6117    equivalent to the static type.  We also handle the case where
6118    INSTANCE is really a pointer. Return negative if this is a
6119    ctor/dtor. There the dynamic type is known, but this might not be
6120    the most derived base of the original object, and hence virtual
6121    bases may not be layed out according to this type.
6122
6123    Used to determine whether the virtual function table is needed
6124    or not.
6125
6126    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6127    of our knowledge of its type.  *NONNULL should be initialized
6128    before this function is called.  */
6129
6130 int
6131 resolves_to_fixed_type_p (tree instance, int* nonnull)
6132 {
6133   tree t = TREE_TYPE (instance);
6134   int cdtorp = 0;
6135   tree fixed;
6136
6137   if (processing_template_decl)
6138     {
6139       /* In a template we only care about the type of the result.  */
6140       if (nonnull)
6141         *nonnull = true;
6142       return true;
6143     }
6144
6145   fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
6146   if (fixed == NULL_TREE)
6147     return 0;
6148   if (POINTER_TYPE_P (t))
6149     t = TREE_TYPE (t);
6150   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
6151     return 0;
6152   return cdtorp ? -1 : 1;
6153 }
6154
6155 \f
6156 void
6157 init_class_processing (void)
6158 {
6159   current_class_depth = 0;
6160   current_class_stack_size = 10;
6161   current_class_stack
6162     = XNEWVEC (struct class_stack_node, current_class_stack_size);
6163   local_classes = VEC_alloc (tree, gc, 8);
6164   sizeof_biggest_empty_class = size_zero_node;
6165
6166   ridpointers[(int) RID_PUBLIC] = access_public_node;
6167   ridpointers[(int) RID_PRIVATE] = access_private_node;
6168   ridpointers[(int) RID_PROTECTED] = access_protected_node;
6169 }
6170
6171 /* Restore the cached PREVIOUS_CLASS_LEVEL.  */
6172
6173 static void
6174 restore_class_cache (void)
6175 {
6176   tree type;
6177
6178   /* We are re-entering the same class we just left, so we don't
6179      have to search the whole inheritance matrix to find all the
6180      decls to bind again.  Instead, we install the cached
6181      class_shadowed list and walk through it binding names.  */
6182   push_binding_level (previous_class_level);
6183   class_binding_level = previous_class_level;
6184   /* Restore IDENTIFIER_TYPE_VALUE.  */
6185   for (type = class_binding_level->type_shadowed;
6186        type;
6187        type = TREE_CHAIN (type))
6188     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
6189 }
6190
6191 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
6192    appropriate for TYPE.
6193
6194    So that we may avoid calls to lookup_name, we cache the _TYPE
6195    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
6196
6197    For multiple inheritance, we perform a two-pass depth-first search
6198    of the type lattice.  */
6199
6200 void
6201 pushclass (tree type)
6202 {
6203   class_stack_node_t csn;
6204
6205   type = TYPE_MAIN_VARIANT (type);
6206
6207   /* Make sure there is enough room for the new entry on the stack.  */
6208   if (current_class_depth + 1 >= current_class_stack_size)
6209     {
6210       current_class_stack_size *= 2;
6211       current_class_stack
6212         = XRESIZEVEC (struct class_stack_node, current_class_stack,
6213                       current_class_stack_size);
6214     }
6215
6216   /* Insert a new entry on the class stack.  */
6217   csn = current_class_stack + current_class_depth;
6218   csn->name = current_class_name;
6219   csn->type = current_class_type;
6220   csn->access = current_access_specifier;
6221   csn->names_used = 0;
6222   csn->hidden = 0;
6223   current_class_depth++;
6224
6225   /* Now set up the new type.  */
6226   current_class_name = TYPE_NAME (type);
6227   if (TREE_CODE (current_class_name) == TYPE_DECL)
6228     current_class_name = DECL_NAME (current_class_name);
6229   current_class_type = type;
6230
6231   /* By default, things in classes are private, while things in
6232      structures or unions are public.  */
6233   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
6234                               ? access_private_node
6235                               : access_public_node);
6236
6237   if (previous_class_level
6238       && type != previous_class_level->this_entity
6239       && current_class_depth == 1)
6240     {
6241       /* Forcibly remove any old class remnants.  */
6242       invalidate_class_lookup_cache ();
6243     }
6244
6245   if (!previous_class_level
6246       || type != previous_class_level->this_entity
6247       || current_class_depth > 1)
6248     pushlevel_class ();
6249   else
6250     restore_class_cache ();
6251 }
6252
6253 /* When we exit a toplevel class scope, we save its binding level so
6254    that we can restore it quickly.  Here, we've entered some other
6255    class, so we must invalidate our cache.  */
6256
6257 void
6258 invalidate_class_lookup_cache (void)
6259 {
6260   previous_class_level = NULL;
6261 }
6262
6263 /* Get out of the current class scope. If we were in a class scope
6264    previously, that is the one popped to.  */
6265
6266 void
6267 popclass (void)
6268 {
6269   poplevel_class ();
6270
6271   current_class_depth--;
6272   current_class_name = current_class_stack[current_class_depth].name;
6273   current_class_type = current_class_stack[current_class_depth].type;
6274   current_access_specifier = current_class_stack[current_class_depth].access;
6275   if (current_class_stack[current_class_depth].names_used)
6276     splay_tree_delete (current_class_stack[current_class_depth].names_used);
6277 }
6278
6279 /* Mark the top of the class stack as hidden.  */
6280
6281 void
6282 push_class_stack (void)
6283 {
6284   if (current_class_depth)
6285     ++current_class_stack[current_class_depth - 1].hidden;
6286 }
6287
6288 /* Mark the top of the class stack as un-hidden.  */
6289
6290 void
6291 pop_class_stack (void)
6292 {
6293   if (current_class_depth)
6294     --current_class_stack[current_class_depth - 1].hidden;
6295 }
6296
6297 /* Returns 1 if the class type currently being defined is either T or
6298    a nested type of T.  */
6299
6300 bool
6301 currently_open_class (tree t)
6302 {
6303   int i;
6304
6305   if (!CLASS_TYPE_P (t))
6306     return false;
6307
6308   t = TYPE_MAIN_VARIANT (t);
6309
6310   /* We start looking from 1 because entry 0 is from global scope,
6311      and has no type.  */
6312   for (i = current_class_depth; i > 0; --i)
6313     {
6314       tree c;
6315       if (i == current_class_depth)
6316         c = current_class_type;
6317       else
6318         {
6319           if (current_class_stack[i].hidden)
6320             break;
6321           c = current_class_stack[i].type;
6322         }
6323       if (!c)
6324         continue;
6325       if (same_type_p (c, t))
6326         return true;
6327     }
6328   return false;
6329 }
6330
6331 /* If either current_class_type or one of its enclosing classes are derived
6332    from T, return the appropriate type.  Used to determine how we found
6333    something via unqualified lookup.  */
6334
6335 tree
6336 currently_open_derived_class (tree t)
6337 {
6338   int i;
6339
6340   /* The bases of a dependent type are unknown.  */
6341   if (dependent_type_p (t))
6342     return NULL_TREE;
6343
6344   if (!current_class_type)
6345     return NULL_TREE;
6346
6347   if (DERIVED_FROM_P (t, current_class_type))
6348     return current_class_type;
6349
6350   for (i = current_class_depth - 1; i > 0; --i)
6351     {
6352       if (current_class_stack[i].hidden)
6353         break;
6354       if (DERIVED_FROM_P (t, current_class_stack[i].type))
6355         return current_class_stack[i].type;
6356     }
6357
6358   return NULL_TREE;
6359 }
6360
6361 /* Returns the innermost class type which is not a lambda closure type.  */
6362
6363 tree
6364 current_nonlambda_class_type (void)
6365 {
6366   int i;
6367
6368   /* We start looking from 1 because entry 0 is from global scope,
6369      and has no type.  */
6370   for (i = current_class_depth; i > 0; --i)
6371     {
6372       tree c;
6373       if (i == current_class_depth)
6374         c = current_class_type;
6375       else
6376         {
6377           if (current_class_stack[i].hidden)
6378             break;
6379           c = current_class_stack[i].type;
6380         }
6381       if (!c)
6382         continue;
6383       if (!LAMBDA_TYPE_P (c))
6384         return c;
6385     }
6386   return NULL_TREE;
6387 }
6388
6389 /* When entering a class scope, all enclosing class scopes' names with
6390    static meaning (static variables, static functions, types and
6391    enumerators) have to be visible.  This recursive function calls
6392    pushclass for all enclosing class contexts until global or a local
6393    scope is reached.  TYPE is the enclosed class.  */
6394
6395 void
6396 push_nested_class (tree type)
6397 {
6398   /* A namespace might be passed in error cases, like A::B:C.  */
6399   if (type == NULL_TREE
6400       || !CLASS_TYPE_P (type))
6401     return;
6402
6403   push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type)));
6404
6405   pushclass (type);
6406 }
6407
6408 /* Undoes a push_nested_class call.  */
6409
6410 void
6411 pop_nested_class (void)
6412 {
6413   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
6414
6415   popclass ();
6416   if (context && CLASS_TYPE_P (context))
6417     pop_nested_class ();
6418 }
6419
6420 /* Returns the number of extern "LANG" blocks we are nested within.  */
6421
6422 int
6423 current_lang_depth (void)
6424 {
6425   return VEC_length (tree, current_lang_base);
6426 }
6427
6428 /* Set global variables CURRENT_LANG_NAME to appropriate value
6429    so that behavior of name-mangling machinery is correct.  */
6430
6431 void
6432 push_lang_context (tree name)
6433 {
6434   VEC_safe_push (tree, gc, current_lang_base, current_lang_name);
6435
6436   if (name == lang_name_cplusplus)
6437     {
6438       current_lang_name = name;
6439     }
6440   else if (name == lang_name_java)
6441     {
6442       current_lang_name = name;
6443       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
6444          (See record_builtin_java_type in decl.c.)  However, that causes
6445          incorrect debug entries if these types are actually used.
6446          So we re-enable debug output after extern "Java".  */
6447       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
6448       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
6449       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
6450       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
6451       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
6452       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
6453       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
6454       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
6455     }
6456   else if (name == lang_name_c)
6457     {
6458       current_lang_name = name;
6459     }
6460   else
6461     error ("language string %<\"%E\"%> not recognized", name);
6462 }
6463
6464 /* Get out of the current language scope.  */
6465
6466 void
6467 pop_lang_context (void)
6468 {
6469   current_lang_name = VEC_pop (tree, current_lang_base);
6470 }
6471 \f
6472 /* Type instantiation routines.  */
6473
6474 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6475    matches the TARGET_TYPE.  If there is no satisfactory match, return
6476    error_mark_node, and issue an error & warning messages under
6477    control of FLAGS.  Permit pointers to member function if FLAGS
6478    permits.  If TEMPLATE_ONLY, the name of the overloaded function was
6479    a template-id, and EXPLICIT_TARGS are the explicitly provided
6480    template arguments.
6481
6482    If OVERLOAD is for one or more member functions, then ACCESS_PATH
6483    is the base path used to reference those member functions.  If
6484    TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
6485    resolved to a member function, access checks will be performed and
6486    errors issued if appropriate.  */
6487
6488 static tree
6489 resolve_address_of_overloaded_function (tree target_type,
6490                                         tree overload,
6491                                         tsubst_flags_t flags,
6492                                         bool template_only,
6493                                         tree explicit_targs,
6494                                         tree access_path)
6495 {
6496   /* Here's what the standard says:
6497
6498        [over.over]
6499
6500        If the name is a function template, template argument deduction
6501        is done, and if the argument deduction succeeds, the deduced
6502        arguments are used to generate a single template function, which
6503        is added to the set of overloaded functions considered.
6504
6505        Non-member functions and static member functions match targets of
6506        type "pointer-to-function" or "reference-to-function."  Nonstatic
6507        member functions match targets of type "pointer-to-member
6508        function;" the function type of the pointer to member is used to
6509        select the member function from the set of overloaded member
6510        functions.  If a nonstatic member function is selected, the
6511        reference to the overloaded function name is required to have the
6512        form of a pointer to member as described in 5.3.1.
6513
6514        If more than one function is selected, any template functions in
6515        the set are eliminated if the set also contains a non-template
6516        function, and any given template function is eliminated if the
6517        set contains a second template function that is more specialized
6518        than the first according to the partial ordering rules 14.5.5.2.
6519        After such eliminations, if any, there shall remain exactly one
6520        selected function.  */
6521
6522   int is_ptrmem = 0;
6523   /* We store the matches in a TREE_LIST rooted here.  The functions
6524      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6525      interoperability with most_specialized_instantiation.  */
6526   tree matches = NULL_TREE;
6527   tree fn;
6528   tree target_fn_type;
6529
6530   /* By the time we get here, we should be seeing only real
6531      pointer-to-member types, not the internal POINTER_TYPE to
6532      METHOD_TYPE representation.  */
6533   gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
6534               || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
6535
6536   gcc_assert (is_overloaded_fn (overload));
6537
6538   /* Check that the TARGET_TYPE is reasonable.  */
6539   if (TYPE_PTRFN_P (target_type))
6540     /* This is OK.  */;
6541   else if (TYPE_PTRMEMFUNC_P (target_type))
6542     /* This is OK, too.  */
6543     is_ptrmem = 1;
6544   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
6545     /* This is OK, too.  This comes from a conversion to reference
6546        type.  */
6547     target_type = build_reference_type (target_type);
6548   else
6549     {
6550       if (flags & tf_error)
6551         error ("cannot resolve overloaded function %qD based on"
6552                " conversion to type %qT",
6553                DECL_NAME (OVL_FUNCTION (overload)), target_type);
6554       return error_mark_node;
6555     }
6556
6557   /* Non-member functions and static member functions match targets of type
6558      "pointer-to-function" or "reference-to-function."  Nonstatic member
6559      functions match targets of type "pointer-to-member-function;" the
6560      function type of the pointer to member is used to select the member
6561      function from the set of overloaded member functions.
6562
6563      So figure out the FUNCTION_TYPE that we want to match against.  */
6564   target_fn_type = static_fn_type (target_type);
6565
6566   /* If we can find a non-template function that matches, we can just
6567      use it.  There's no point in generating template instantiations
6568      if we're just going to throw them out anyhow.  But, of course, we
6569      can only do this when we don't *need* a template function.  */
6570   if (!template_only)
6571     {
6572       tree fns;
6573
6574       for (fns = overload; fns; fns = OVL_NEXT (fns))
6575         {
6576           tree fn = OVL_CURRENT (fns);
6577
6578           if (TREE_CODE (fn) == TEMPLATE_DECL)
6579             /* We're not looking for templates just yet.  */
6580             continue;
6581
6582           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6583               != is_ptrmem)
6584             /* We're looking for a non-static member, and this isn't
6585                one, or vice versa.  */
6586             continue;
6587
6588           /* Ignore functions which haven't been explicitly
6589              declared.  */
6590           if (DECL_ANTICIPATED (fn))
6591             continue;
6592
6593           /* See if there's a match.  */
6594           if (same_type_p (target_fn_type, static_fn_type (fn)))
6595             matches = tree_cons (fn, NULL_TREE, matches);
6596         }
6597     }
6598
6599   /* Now, if we've already got a match (or matches), there's no need
6600      to proceed to the template functions.  But, if we don't have a
6601      match we need to look at them, too.  */
6602   if (!matches)
6603     {
6604       tree target_arg_types;
6605       tree target_ret_type;
6606       tree fns;
6607       tree *args;
6608       unsigned int nargs, ia;
6609       tree arg;
6610
6611       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
6612       target_ret_type = TREE_TYPE (target_fn_type);
6613
6614       nargs = list_length (target_arg_types);
6615       args = XALLOCAVEC (tree, nargs);
6616       for (arg = target_arg_types, ia = 0;
6617            arg != NULL_TREE && arg != void_list_node;
6618            arg = TREE_CHAIN (arg), ++ia)
6619         args[ia] = TREE_VALUE (arg);
6620       nargs = ia;
6621
6622       for (fns = overload; fns; fns = OVL_NEXT (fns))
6623         {
6624           tree fn = OVL_CURRENT (fns);
6625           tree instantiation;
6626           tree targs;
6627
6628           if (TREE_CODE (fn) != TEMPLATE_DECL)
6629             /* We're only looking for templates.  */
6630             continue;
6631
6632           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6633               != is_ptrmem)
6634             /* We're not looking for a non-static member, and this is
6635                one, or vice versa.  */
6636             continue;
6637
6638           /* Try to do argument deduction.  */
6639           targs = make_tree_vec (DECL_NTPARMS (fn));
6640           if (fn_type_unification (fn, explicit_targs, targs, args, nargs,
6641                                    target_ret_type, DEDUCE_EXACT,
6642                                    LOOKUP_NORMAL, false))
6643             /* Argument deduction failed.  */
6644             continue;
6645
6646           /* Instantiate the template.  */
6647           instantiation = instantiate_template (fn, targs, flags);
6648           if (instantiation == error_mark_node)
6649             /* Instantiation failed.  */
6650             continue;
6651
6652           /* See if there's a match.  */
6653           if (same_type_p (target_fn_type, static_fn_type (instantiation)))
6654             matches = tree_cons (instantiation, fn, matches);
6655         }
6656
6657       /* Now, remove all but the most specialized of the matches.  */
6658       if (matches)
6659         {
6660           tree match = most_specialized_instantiation (matches);
6661
6662           if (match != error_mark_node)
6663             matches = tree_cons (TREE_PURPOSE (match),
6664                                  NULL_TREE,
6665                                  NULL_TREE);
6666         }
6667     }
6668
6669   /* Now we should have exactly one function in MATCHES.  */
6670   if (matches == NULL_TREE)
6671     {
6672       /* There were *no* matches.  */
6673       if (flags & tf_error)
6674         {
6675           error ("no matches converting function %qD to type %q#T",
6676                  DECL_NAME (OVL_CURRENT (overload)),
6677                  target_type);
6678
6679           print_candidates (overload);
6680         }
6681       return error_mark_node;
6682     }
6683   else if (TREE_CHAIN (matches))
6684     {
6685       /* There were too many matches.  First check if they're all
6686          the same function.  */
6687       tree match;
6688
6689       fn = TREE_PURPOSE (matches);
6690       for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match))
6691         if (!decls_match (fn, TREE_PURPOSE (match)))
6692           break;
6693
6694       if (match)
6695         {
6696           if (flags & tf_error)
6697             {
6698               error ("converting overloaded function %qD to type %q#T is ambiguous",
6699                      DECL_NAME (OVL_FUNCTION (overload)),
6700                      target_type);
6701
6702               /* Since print_candidates expects the functions in the
6703                  TREE_VALUE slot, we flip them here.  */
6704               for (match = matches; match; match = TREE_CHAIN (match))
6705                 TREE_VALUE (match) = TREE_PURPOSE (match);
6706
6707               print_candidates (matches);
6708             }
6709
6710           return error_mark_node;
6711         }
6712     }
6713
6714   /* Good, exactly one match.  Now, convert it to the correct type.  */
6715   fn = TREE_PURPOSE (matches);
6716
6717   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
6718       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
6719     {
6720       static int explained;
6721
6722       if (!(flags & tf_error))
6723         return error_mark_node;
6724
6725       permerror (input_location, "assuming pointer to member %qD", fn);
6726       if (!explained)
6727         {
6728           inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
6729           explained = 1;
6730         }
6731     }
6732
6733   /* If we're doing overload resolution purely for the purpose of
6734      determining conversion sequences, we should not consider the
6735      function used.  If this conversion sequence is selected, the
6736      function will be marked as used at this point.  */
6737   if (!(flags & tf_conv))
6738     {
6739       /* Make =delete work with SFINAE.  */
6740       if (DECL_DELETED_FN (fn) && !(flags & tf_error))
6741         return error_mark_node;
6742
6743       mark_used (fn);
6744     }
6745
6746   /* We could not check access to member functions when this
6747      expression was originally created since we did not know at that
6748      time to which function the expression referred.  */
6749   if (!(flags & tf_no_access_control)
6750       && DECL_FUNCTION_MEMBER_P (fn))
6751     {
6752       gcc_assert (access_path);
6753       perform_or_defer_access_check (access_path, fn, fn);
6754     }
6755
6756   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
6757     return cp_build_addr_expr (fn, flags);
6758   else
6759     {
6760       /* The target must be a REFERENCE_TYPE.  Above, cp_build_unary_op
6761          will mark the function as addressed, but here we must do it
6762          explicitly.  */
6763       cxx_mark_addressable (fn);
6764
6765       return fn;
6766     }
6767 }
6768
6769 /* This function will instantiate the type of the expression given in
6770    RHS to match the type of LHSTYPE.  If errors exist, then return
6771    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
6772    we complain on errors.  If we are not complaining, never modify rhs,
6773    as overload resolution wants to try many possible instantiations, in
6774    the hope that at least one will work.
6775
6776    For non-recursive calls, LHSTYPE should be a function, pointer to
6777    function, or a pointer to member function.  */
6778
6779 tree
6780 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6781 {
6782   tsubst_flags_t flags_in = flags;
6783   tree access_path = NULL_TREE;
6784
6785   flags &= ~tf_ptrmem_ok;
6786
6787   if (lhstype == unknown_type_node)
6788     {
6789       if (flags & tf_error)
6790         error ("not enough type information");
6791       return error_mark_node;
6792     }
6793
6794   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6795     {
6796       if (same_type_p (lhstype, TREE_TYPE (rhs)))
6797         return rhs;
6798       if (flag_ms_extensions
6799           && TYPE_PTRMEMFUNC_P (lhstype)
6800           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6801         /* Microsoft allows `A::f' to be resolved to a
6802            pointer-to-member.  */
6803         ;
6804       else
6805         {
6806           if (flags & tf_error)
6807             error ("argument of type %qT does not match %qT",
6808                    TREE_TYPE (rhs), lhstype);
6809           return error_mark_node;
6810         }
6811     }
6812
6813   if (TREE_CODE (rhs) == BASELINK)
6814     {
6815       access_path = BASELINK_ACCESS_BINFO (rhs);
6816       rhs = BASELINK_FUNCTIONS (rhs);
6817     }
6818
6819   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6820      deduce any type information.  */
6821   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6822     {
6823       if (flags & tf_error)
6824         error ("not enough type information");
6825       return error_mark_node;
6826     }
6827
6828   /* There only a few kinds of expressions that may have a type
6829      dependent on overload resolution.  */
6830   gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6831               || TREE_CODE (rhs) == COMPONENT_REF
6832               || really_overloaded_fn (rhs)
6833               || (flag_ms_extensions && TREE_CODE (rhs) == FUNCTION_DECL));
6834
6835   /* This should really only be used when attempting to distinguish
6836      what sort of a pointer to function we have.  For now, any
6837      arithmetic operation which is not supported on pointers
6838      is rejected as an error.  */
6839
6840   switch (TREE_CODE (rhs))
6841     {
6842     case COMPONENT_REF:
6843       {
6844         tree member = TREE_OPERAND (rhs, 1);
6845
6846         member = instantiate_type (lhstype, member, flags);
6847         if (member != error_mark_node
6848             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6849           /* Do not lose object's side effects.  */
6850           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6851                          TREE_OPERAND (rhs, 0), member);
6852         return member;
6853       }
6854
6855     case OFFSET_REF:
6856       rhs = TREE_OPERAND (rhs, 1);
6857       if (BASELINK_P (rhs))
6858         return instantiate_type (lhstype, rhs, flags_in);
6859
6860       /* This can happen if we are forming a pointer-to-member for a
6861          member template.  */
6862       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6863
6864       /* Fall through.  */
6865
6866     case TEMPLATE_ID_EXPR:
6867       {
6868         tree fns = TREE_OPERAND (rhs, 0);
6869         tree args = TREE_OPERAND (rhs, 1);
6870
6871         return
6872           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6873                                                   /*template_only=*/true,
6874                                                   args, access_path);
6875       }
6876
6877     case OVERLOAD:
6878     case FUNCTION_DECL:
6879       return
6880         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6881                                                 /*template_only=*/false,
6882                                                 /*explicit_targs=*/NULL_TREE,
6883                                                 access_path);
6884
6885     case ADDR_EXPR:
6886     {
6887       if (PTRMEM_OK_P (rhs))
6888         flags |= tf_ptrmem_ok;
6889
6890       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6891     }
6892
6893     case ERROR_MARK:
6894       return error_mark_node;
6895
6896     default:
6897       gcc_unreachable ();
6898     }
6899   return error_mark_node;
6900 }
6901 \f
6902 /* Return the name of the virtual function pointer field
6903    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6904    this may have to look back through base types to find the
6905    ultimate field name.  (For single inheritance, these could
6906    all be the same name.  Who knows for multiple inheritance).  */
6907
6908 static tree
6909 get_vfield_name (tree type)
6910 {
6911   tree binfo, base_binfo;
6912   char *buf;
6913
6914   for (binfo = TYPE_BINFO (type);
6915        BINFO_N_BASE_BINFOS (binfo);
6916        binfo = base_binfo)
6917     {
6918       base_binfo = BINFO_BASE_BINFO (binfo, 0);
6919
6920       if (BINFO_VIRTUAL_P (base_binfo)
6921           || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6922         break;
6923     }
6924
6925   type = BINFO_TYPE (binfo);
6926   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6927                          + TYPE_NAME_LENGTH (type) + 2);
6928   sprintf (buf, VFIELD_NAME_FORMAT,
6929            IDENTIFIER_POINTER (constructor_name (type)));
6930   return get_identifier (buf);
6931 }
6932
6933 void
6934 print_class_statistics (void)
6935 {
6936 #ifdef GATHER_STATISTICS
6937   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6938   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6939   if (n_vtables)
6940     {
6941       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6942                n_vtables, n_vtable_searches);
6943       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6944                n_vtable_entries, n_vtable_elems);
6945     }
6946 #endif
6947 }
6948
6949 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6950    according to [class]:
6951                                           The class-name is also inserted
6952    into  the scope of the class itself.  For purposes of access checking,
6953    the inserted class name is treated as if it were a public member name.  */
6954
6955 void
6956 build_self_reference (void)
6957 {
6958   tree name = constructor_name (current_class_type);
6959   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6960   tree saved_cas;
6961
6962   DECL_NONLOCAL (value) = 1;
6963   DECL_CONTEXT (value) = current_class_type;
6964   DECL_ARTIFICIAL (value) = 1;
6965   SET_DECL_SELF_REFERENCE_P (value);
6966   set_underlying_type (value);
6967
6968   if (processing_template_decl)
6969     value = push_template_decl (value);
6970
6971   saved_cas = current_access_specifier;
6972   current_access_specifier = access_public_node;
6973   finish_member_declaration (value);
6974   current_access_specifier = saved_cas;
6975 }
6976
6977 /* Returns 1 if TYPE contains only padding bytes.  */
6978
6979 int
6980 is_empty_class (tree type)
6981 {
6982   if (type == error_mark_node)
6983     return 0;
6984
6985   if (! CLASS_TYPE_P (type))
6986     return 0;
6987
6988   /* In G++ 3.2, whether or not a class was empty was determined by
6989      looking at its size.  */
6990   if (abi_version_at_least (2))
6991     return CLASSTYPE_EMPTY_P (type);
6992   else
6993     return integer_zerop (CLASSTYPE_SIZE (type));
6994 }
6995
6996 /* Returns true if TYPE contains an empty class.  */
6997
6998 static bool
6999 contains_empty_class_p (tree type)
7000 {
7001   if (is_empty_class (type))
7002     return true;
7003   if (CLASS_TYPE_P (type))
7004     {
7005       tree field;
7006       tree binfo;
7007       tree base_binfo;
7008       int i;
7009
7010       for (binfo = TYPE_BINFO (type), i = 0;
7011            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7012         if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
7013           return true;
7014       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
7015         if (TREE_CODE (field) == FIELD_DECL
7016             && !DECL_ARTIFICIAL (field)
7017             && is_empty_class (TREE_TYPE (field)))
7018           return true;
7019     }
7020   else if (TREE_CODE (type) == ARRAY_TYPE)
7021     return contains_empty_class_p (TREE_TYPE (type));
7022   return false;
7023 }
7024
7025 /* Returns true if TYPE contains no actual data, just various
7026    possible combinations of empty classes and possibly a vptr.  */
7027
7028 bool
7029 is_really_empty_class (tree type)
7030 {
7031   if (CLASS_TYPE_P (type))
7032     {
7033       tree field;
7034       tree binfo;
7035       tree base_binfo;
7036       int i;
7037
7038       /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
7039          out, but we'd like to be able to check this before then.  */
7040       if (COMPLETE_TYPE_P (type) && is_empty_class (type))
7041         return true;
7042
7043       for (binfo = TYPE_BINFO (type), i = 0;
7044            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7045         if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
7046           return false;
7047       for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
7048         if (TREE_CODE (field) == FIELD_DECL
7049             && !DECL_ARTIFICIAL (field)
7050             && !is_really_empty_class (TREE_TYPE (field)))
7051           return false;
7052       return true;
7053     }
7054   else if (TREE_CODE (type) == ARRAY_TYPE)
7055     return is_really_empty_class (TREE_TYPE (type));
7056   return false;
7057 }
7058
7059 /* Note that NAME was looked up while the current class was being
7060    defined and that the result of that lookup was DECL.  */
7061
7062 void
7063 maybe_note_name_used_in_class (tree name, tree decl)
7064 {
7065   splay_tree names_used;
7066
7067   /* If we're not defining a class, there's nothing to do.  */
7068   if (!(innermost_scope_kind() == sk_class
7069         && TYPE_BEING_DEFINED (current_class_type)
7070         && !LAMBDA_TYPE_P (current_class_type)))
7071     return;
7072
7073   /* If there's already a binding for this NAME, then we don't have
7074      anything to worry about.  */
7075   if (lookup_member (current_class_type, name,
7076                      /*protect=*/0, /*want_type=*/false))
7077     return;
7078
7079   if (!current_class_stack[current_class_depth - 1].names_used)
7080     current_class_stack[current_class_depth - 1].names_used
7081       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
7082   names_used = current_class_stack[current_class_depth - 1].names_used;
7083
7084   splay_tree_insert (names_used,
7085                      (splay_tree_key) name,
7086                      (splay_tree_value) decl);
7087 }
7088
7089 /* Note that NAME was declared (as DECL) in the current class.  Check
7090    to see that the declaration is valid.  */
7091
7092 void
7093 note_name_declared_in_class (tree name, tree decl)
7094 {
7095   splay_tree names_used;
7096   splay_tree_node n;
7097
7098   /* Look to see if we ever used this name.  */
7099   names_used
7100     = current_class_stack[current_class_depth - 1].names_used;
7101   if (!names_used)
7102     return;
7103   /* The C language allows members to be declared with a type of the same
7104      name, and the C++ standard says this diagnostic is not required.  So
7105      allow it in extern "C" blocks unless predantic is specified.
7106      Allow it in all cases if -ms-extensions is specified.  */
7107   if ((!pedantic && current_lang_name == lang_name_c)
7108       || flag_ms_extensions)
7109     return;
7110   n = splay_tree_lookup (names_used, (splay_tree_key) name);
7111   if (n)
7112     {
7113       /* [basic.scope.class]
7114
7115          A name N used in a class S shall refer to the same declaration
7116          in its context and when re-evaluated in the completed scope of
7117          S.  */
7118       permerror (input_location, "declaration of %q#D", decl);
7119       permerror (input_location, "changes meaning of %qD from %q+#D",
7120                DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
7121     }
7122 }
7123
7124 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
7125    Secondary vtables are merged with primary vtables; this function
7126    will return the VAR_DECL for the primary vtable.  */
7127
7128 tree
7129 get_vtbl_decl_for_binfo (tree binfo)
7130 {
7131   tree decl;
7132
7133   decl = BINFO_VTABLE (binfo);
7134   if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR)
7135     {
7136       gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
7137       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
7138     }
7139   if (decl)
7140     gcc_assert (TREE_CODE (decl) == VAR_DECL);
7141   return decl;
7142 }
7143
7144
7145 /* Returns the binfo for the primary base of BINFO.  If the resulting
7146    BINFO is a virtual base, and it is inherited elsewhere in the
7147    hierarchy, then the returned binfo might not be the primary base of
7148    BINFO in the complete object.  Check BINFO_PRIMARY_P or
7149    BINFO_LOST_PRIMARY_P to be sure.  */
7150
7151 static tree
7152 get_primary_binfo (tree binfo)
7153 {
7154   tree primary_base;
7155
7156   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
7157   if (!primary_base)
7158     return NULL_TREE;
7159
7160   return copied_binfo (primary_base, binfo);
7161 }
7162
7163 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
7164
7165 static int
7166 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
7167 {
7168   if (!indented_p)
7169     fprintf (stream, "%*s", indent, "");
7170   return 1;
7171 }
7172
7173 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
7174    INDENT should be zero when called from the top level; it is
7175    incremented recursively.  IGO indicates the next expected BINFO in
7176    inheritance graph ordering.  */
7177
7178 static tree
7179 dump_class_hierarchy_r (FILE *stream,
7180                         int flags,
7181                         tree binfo,
7182                         tree igo,
7183                         int indent)
7184 {
7185   int indented = 0;
7186   tree base_binfo;
7187   int i;
7188
7189   indented = maybe_indent_hierarchy (stream, indent, 0);
7190   fprintf (stream, "%s (0x%lx) ",
7191            type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
7192            (unsigned long) binfo);
7193   if (binfo != igo)
7194     {
7195       fprintf (stream, "alternative-path\n");
7196       return igo;
7197     }
7198   igo = TREE_CHAIN (binfo);
7199
7200   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
7201            tree_low_cst (BINFO_OFFSET (binfo), 0));
7202   if (is_empty_class (BINFO_TYPE (binfo)))
7203     fprintf (stream, " empty");
7204   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
7205     fprintf (stream, " nearly-empty");
7206   if (BINFO_VIRTUAL_P (binfo))
7207     fprintf (stream, " virtual");
7208   fprintf (stream, "\n");
7209
7210   indented = 0;
7211   if (BINFO_PRIMARY_P (binfo))
7212     {
7213       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7214       fprintf (stream, " primary-for %s (0x%lx)",
7215                type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
7216                                TFF_PLAIN_IDENTIFIER),
7217                (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
7218     }
7219   if (BINFO_LOST_PRIMARY_P (binfo))
7220     {
7221       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7222       fprintf (stream, " lost-primary");
7223     }
7224   if (indented)
7225     fprintf (stream, "\n");
7226
7227   if (!(flags & TDF_SLIM))
7228     {
7229       int indented = 0;
7230
7231       if (BINFO_SUBVTT_INDEX (binfo))
7232         {
7233           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7234           fprintf (stream, " subvttidx=%s",
7235                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
7236                                    TFF_PLAIN_IDENTIFIER));
7237         }
7238       if (BINFO_VPTR_INDEX (binfo))
7239         {
7240           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7241           fprintf (stream, " vptridx=%s",
7242                    expr_as_string (BINFO_VPTR_INDEX (binfo),
7243                                    TFF_PLAIN_IDENTIFIER));
7244         }
7245       if (BINFO_VPTR_FIELD (binfo))
7246         {
7247           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7248           fprintf (stream, " vbaseoffset=%s",
7249                    expr_as_string (BINFO_VPTR_FIELD (binfo),
7250                                    TFF_PLAIN_IDENTIFIER));
7251         }
7252       if (BINFO_VTABLE (binfo))
7253         {
7254           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7255           fprintf (stream, " vptr=%s",
7256                    expr_as_string (BINFO_VTABLE (binfo),
7257                                    TFF_PLAIN_IDENTIFIER));
7258         }
7259
7260       if (indented)
7261         fprintf (stream, "\n");
7262     }
7263
7264   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
7265     igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
7266
7267   return igo;
7268 }
7269
7270 /* Dump the BINFO hierarchy for T.  */
7271
7272 static void
7273 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
7274 {
7275   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
7276   fprintf (stream, "   size=%lu align=%lu\n",
7277            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
7278            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
7279   fprintf (stream, "   base size=%lu base align=%lu\n",
7280            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
7281                            / BITS_PER_UNIT),
7282            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
7283                            / BITS_PER_UNIT));
7284   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
7285   fprintf (stream, "\n");
7286 }
7287
7288 /* Debug interface to hierarchy dumping.  */
7289
7290 void
7291 debug_class (tree t)
7292 {
7293   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
7294 }
7295
7296 static void
7297 dump_class_hierarchy (tree t)
7298 {
7299   int flags;
7300   FILE *stream = dump_begin (TDI_class, &flags);
7301
7302   if (stream)
7303     {
7304       dump_class_hierarchy_1 (stream, flags, t);
7305       dump_end (TDI_class, stream);
7306     }
7307 }
7308
7309 static void
7310 dump_array (FILE * stream, tree decl)
7311 {
7312   tree value;
7313   unsigned HOST_WIDE_INT ix;
7314   HOST_WIDE_INT elt;
7315   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
7316
7317   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
7318          / BITS_PER_UNIT);
7319   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
7320   fprintf (stream, " %s entries",
7321            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
7322                            TFF_PLAIN_IDENTIFIER));
7323   fprintf (stream, "\n");
7324
7325   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
7326                               ix, value)
7327     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
7328              expr_as_string (value, TFF_PLAIN_IDENTIFIER));
7329 }
7330
7331 static void
7332 dump_vtable (tree t, tree binfo, tree vtable)
7333 {
7334   int flags;
7335   FILE *stream = dump_begin (TDI_class, &flags);
7336
7337   if (!stream)
7338     return;
7339
7340   if (!(flags & TDF_SLIM))
7341     {
7342       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
7343
7344       fprintf (stream, "%s for %s",
7345                ctor_vtbl_p ? "Construction vtable" : "Vtable",
7346                type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
7347       if (ctor_vtbl_p)
7348         {
7349           if (!BINFO_VIRTUAL_P (binfo))
7350             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
7351           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
7352         }
7353       fprintf (stream, "\n");
7354       dump_array (stream, vtable);
7355       fprintf (stream, "\n");
7356     }
7357
7358   dump_end (TDI_class, stream);
7359 }
7360
7361 static void
7362 dump_vtt (tree t, tree vtt)
7363 {
7364   int flags;
7365   FILE *stream = dump_begin (TDI_class, &flags);
7366
7367   if (!stream)
7368     return;
7369
7370   if (!(flags & TDF_SLIM))
7371     {
7372       fprintf (stream, "VTT for %s\n",
7373                type_as_string (t, TFF_PLAIN_IDENTIFIER));
7374       dump_array (stream, vtt);
7375       fprintf (stream, "\n");
7376     }
7377
7378   dump_end (TDI_class, stream);
7379 }
7380
7381 /* Dump a function or thunk and its thunkees.  */
7382
7383 static void
7384 dump_thunk (FILE *stream, int indent, tree thunk)
7385 {
7386   static const char spaces[] = "        ";
7387   tree name = DECL_NAME (thunk);
7388   tree thunks;
7389
7390   fprintf (stream, "%.*s%p %s %s", indent, spaces,
7391            (void *)thunk,
7392            !DECL_THUNK_P (thunk) ? "function"
7393            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
7394            name ? IDENTIFIER_POINTER (name) : "<unset>");
7395   if (DECL_THUNK_P (thunk))
7396     {
7397       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
7398       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
7399
7400       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
7401       if (!virtual_adjust)
7402         /*NOP*/;
7403       else if (DECL_THIS_THUNK_P (thunk))
7404         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
7405                  tree_low_cst (virtual_adjust, 0));
7406       else
7407         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
7408                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
7409                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
7410       if (THUNK_ALIAS (thunk))
7411         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
7412     }
7413   fprintf (stream, "\n");
7414   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
7415     dump_thunk (stream, indent + 2, thunks);
7416 }
7417
7418 /* Dump the thunks for FN.  */
7419
7420 void
7421 debug_thunks (tree fn)
7422 {
7423   dump_thunk (stderr, 0, fn);
7424 }
7425
7426 /* Virtual function table initialization.  */
7427
7428 /* Create all the necessary vtables for T and its base classes.  */
7429
7430 static void
7431 finish_vtbls (tree t)
7432 {
7433   tree vbase;
7434   VEC(constructor_elt,gc) *v = NULL;
7435   tree vtable = BINFO_VTABLE (TYPE_BINFO (t));
7436
7437   /* We lay out the primary and secondary vtables in one contiguous
7438      vtable.  The primary vtable is first, followed by the non-virtual
7439      secondary vtables in inheritance graph order.  */
7440   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t), TYPE_BINFO (t),
7441                          vtable, t, &v);
7442
7443   /* Then come the virtual bases, also in inheritance graph order.  */
7444   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
7445     {
7446       if (!BINFO_VIRTUAL_P (vbase))
7447         continue;
7448       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), vtable, t, &v);
7449     }
7450
7451   if (BINFO_VTABLE (TYPE_BINFO (t)))
7452     initialize_vtable (TYPE_BINFO (t), v);
7453 }
7454
7455 /* Initialize the vtable for BINFO with the INITS.  */
7456
7457 static void
7458 initialize_vtable (tree binfo, VEC(constructor_elt,gc) *inits)
7459 {
7460   tree decl;
7461
7462   layout_vtable_decl (binfo, VEC_length (constructor_elt, inits));
7463   decl = get_vtbl_decl_for_binfo (binfo);
7464   initialize_artificial_var (decl, inits);
7465   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
7466 }
7467
7468 /* Build the VTT (virtual table table) for T.
7469    A class requires a VTT if it has virtual bases.
7470
7471    This holds
7472    1 - primary virtual pointer for complete object T
7473    2 - secondary VTTs for each direct non-virtual base of T which requires a
7474        VTT
7475    3 - secondary virtual pointers for each direct or indirect base of T which
7476        has virtual bases or is reachable via a virtual path from T.
7477    4 - secondary VTTs for each direct or indirect virtual base of T.
7478
7479    Secondary VTTs look like complete object VTTs without part 4.  */
7480
7481 static void
7482 build_vtt (tree t)
7483 {
7484   tree type;
7485   tree vtt;
7486   tree index;
7487   VEC(constructor_elt,gc) *inits;
7488
7489   /* Build up the initializers for the VTT.  */
7490   inits = NULL;
7491   index = size_zero_node;
7492   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
7493
7494   /* If we didn't need a VTT, we're done.  */
7495   if (!inits)
7496     return;
7497
7498   /* Figure out the type of the VTT.  */
7499   type = build_array_of_n_type (const_ptr_type_node,
7500                                 VEC_length (constructor_elt, inits));
7501
7502   /* Now, build the VTT object itself.  */
7503   vtt = build_vtable (t, mangle_vtt_for_type (t), type);
7504   initialize_artificial_var (vtt, inits);
7505   /* Add the VTT to the vtables list.  */
7506   DECL_CHAIN (vtt) = DECL_CHAIN (CLASSTYPE_VTABLES (t));
7507   DECL_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
7508
7509   dump_vtt (t, vtt);
7510 }
7511
7512 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7513    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7514    and CHAIN the vtable pointer for this binfo after construction is
7515    complete.  VALUE can also be another BINFO, in which case we recurse.  */
7516
7517 static tree
7518 binfo_ctor_vtable (tree binfo)
7519 {
7520   tree vt;
7521
7522   while (1)
7523     {
7524       vt = BINFO_VTABLE (binfo);
7525       if (TREE_CODE (vt) == TREE_LIST)
7526         vt = TREE_VALUE (vt);
7527       if (TREE_CODE (vt) == TREE_BINFO)
7528         binfo = vt;
7529       else
7530         break;
7531     }
7532
7533   return vt;
7534 }
7535
7536 /* Data for secondary VTT initialization.  */
7537 typedef struct secondary_vptr_vtt_init_data_s
7538 {
7539   /* Is this the primary VTT? */
7540   bool top_level_p;
7541
7542   /* Current index into the VTT.  */
7543   tree index;
7544
7545   /* Vector of initializers built up.  */
7546   VEC(constructor_elt,gc) *inits;
7547
7548   /* The type being constructed by this secondary VTT.  */
7549   tree type_being_constructed;
7550 } secondary_vptr_vtt_init_data;
7551
7552 /* Recursively build the VTT-initializer for BINFO (which is in the
7553    hierarchy dominated by T).  INITS points to the end of the initializer
7554    list to date.  INDEX is the VTT index where the next element will be
7555    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7556    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
7557    for virtual bases of T. When it is not so, we build the constructor
7558    vtables for the BINFO-in-T variant.  */
7559
7560 static void
7561 build_vtt_inits (tree binfo, tree t, VEC(constructor_elt,gc) **inits, tree *index)
7562 {
7563   int i;
7564   tree b;
7565   tree init;
7566   secondary_vptr_vtt_init_data data;
7567   int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7568
7569   /* We only need VTTs for subobjects with virtual bases.  */
7570   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7571     return;
7572
7573   /* We need to use a construction vtable if this is not the primary
7574      VTT.  */
7575   if (!top_level_p)
7576     {
7577       build_ctor_vtbl_group (binfo, t);
7578
7579       /* Record the offset in the VTT where this sub-VTT can be found.  */
7580       BINFO_SUBVTT_INDEX (binfo) = *index;
7581     }
7582
7583   /* Add the address of the primary vtable for the complete object.  */
7584   init = binfo_ctor_vtable (binfo);
7585   CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
7586   if (top_level_p)
7587     {
7588       gcc_assert (!BINFO_VPTR_INDEX (binfo));
7589       BINFO_VPTR_INDEX (binfo) = *index;
7590     }
7591   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
7592
7593   /* Recursively add the secondary VTTs for non-virtual bases.  */
7594   for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
7595     if (!BINFO_VIRTUAL_P (b))
7596       build_vtt_inits (b, t, inits, index);
7597
7598   /* Add secondary virtual pointers for all subobjects of BINFO with
7599      either virtual bases or reachable along a virtual path, except
7600      subobjects that are non-virtual primary bases.  */
7601   data.top_level_p = top_level_p;
7602   data.index = *index;
7603   data.inits = *inits;
7604   data.type_being_constructed = BINFO_TYPE (binfo);
7605
7606   dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
7607
7608   *index = data.index;
7609
7610   /* data.inits might have grown as we added secondary virtual pointers.
7611      Make sure our caller knows about the new vector.  */
7612   *inits = data.inits;
7613
7614   if (top_level_p)
7615     /* Add the secondary VTTs for virtual bases in inheritance graph
7616        order.  */
7617     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
7618       {
7619         if (!BINFO_VIRTUAL_P (b))
7620           continue;
7621
7622         build_vtt_inits (b, t, inits, index);
7623       }
7624   else
7625     /* Remove the ctor vtables we created.  */
7626     dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
7627 }
7628
7629 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo for the base
7630    in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure.  */
7631
7632 static tree
7633 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
7634 {
7635   secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
7636
7637   /* We don't care about bases that don't have vtables.  */
7638   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7639     return dfs_skip_bases;
7640
7641   /* We're only interested in proper subobjects of the type being
7642      constructed.  */
7643   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
7644     return NULL_TREE;
7645
7646   /* We're only interested in bases with virtual bases or reachable
7647      via a virtual path from the type being constructed.  */
7648   if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7649         || binfo_via_virtual (binfo, data->type_being_constructed)))
7650     return dfs_skip_bases;
7651
7652   /* We're not interested in non-virtual primary bases.  */
7653   if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
7654     return NULL_TREE;
7655
7656   /* Record the index where this secondary vptr can be found.  */
7657   if (data->top_level_p)
7658     {
7659       gcc_assert (!BINFO_VPTR_INDEX (binfo));
7660       BINFO_VPTR_INDEX (binfo) = data->index;
7661
7662       if (BINFO_VIRTUAL_P (binfo))
7663         {
7664           /* It's a primary virtual base, and this is not a
7665              construction vtable.  Find the base this is primary of in
7666              the inheritance graph, and use that base's vtable
7667              now.  */
7668           while (BINFO_PRIMARY_P (binfo))
7669             binfo = BINFO_INHERITANCE_CHAIN (binfo);
7670         }
7671     }
7672
7673   /* Add the initializer for the secondary vptr itself.  */
7674   CONSTRUCTOR_APPEND_ELT (data->inits, NULL_TREE, binfo_ctor_vtable (binfo));
7675
7676   /* Advance the vtt index.  */
7677   data->index = size_binop (PLUS_EXPR, data->index,
7678                             TYPE_SIZE_UNIT (ptr_type_node));
7679
7680   return NULL_TREE;
7681 }
7682
7683 /* Called from build_vtt_inits via dfs_walk. After building
7684    constructor vtables and generating the sub-vtt from them, we need
7685    to restore the BINFO_VTABLES that were scribbled on.  DATA is the
7686    binfo of the base whose sub vtt was generated.  */
7687
7688 static tree
7689 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7690 {
7691   tree vtable = BINFO_VTABLE (binfo);
7692
7693   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7694     /* If this class has no vtable, none of its bases do.  */
7695     return dfs_skip_bases;
7696
7697   if (!vtable)
7698     /* This might be a primary base, so have no vtable in this
7699        hierarchy.  */
7700     return NULL_TREE;
7701
7702   /* If we scribbled the construction vtable vptr into BINFO, clear it
7703      out now.  */
7704   if (TREE_CODE (vtable) == TREE_LIST
7705       && (TREE_PURPOSE (vtable) == (tree) data))
7706     BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
7707
7708   return NULL_TREE;
7709 }
7710
7711 /* Build the construction vtable group for BINFO which is in the
7712    hierarchy dominated by T.  */
7713
7714 static void
7715 build_ctor_vtbl_group (tree binfo, tree t)
7716 {
7717   tree type;
7718   tree vtbl;
7719   tree id;
7720   tree vbase;
7721   VEC(constructor_elt,gc) *v;
7722
7723   /* See if we've already created this construction vtable group.  */
7724   id = mangle_ctor_vtbl_for_type (t, binfo);
7725   if (IDENTIFIER_GLOBAL_VALUE (id))
7726     return;
7727
7728   gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
7729   /* Build a version of VTBL (with the wrong type) for use in
7730      constructing the addresses of secondary vtables in the
7731      construction vtable group.  */
7732   vtbl = build_vtable (t, id, ptr_type_node);
7733   DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
7734
7735   v = NULL;
7736   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7737                          binfo, vtbl, t, &v);
7738
7739   /* Add the vtables for each of our virtual bases using the vbase in T
7740      binfo.  */
7741   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7742        vbase;
7743        vbase = TREE_CHAIN (vbase))
7744     {
7745       tree b;
7746
7747       if (!BINFO_VIRTUAL_P (vbase))
7748         continue;
7749       b = copied_binfo (vbase, binfo);
7750
7751       accumulate_vtbl_inits (b, vbase, binfo, vtbl, t, &v);
7752     }
7753
7754   /* Figure out the type of the construction vtable.  */
7755   type = build_array_of_n_type (vtable_entry_type,
7756                                 VEC_length (constructor_elt, v));
7757   layout_type (type);
7758   TREE_TYPE (vtbl) = type;
7759   DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE;
7760   layout_decl (vtbl, 0);
7761
7762   /* Initialize the construction vtable.  */
7763   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7764   initialize_artificial_var (vtbl, v);
7765   dump_vtable (t, binfo, vtbl);
7766 }
7767
7768 /* Add the vtbl initializers for BINFO (and its bases other than
7769    non-virtual primaries) to the list of INITS.  BINFO is in the
7770    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
7771    the constructor the vtbl inits should be accumulated for. (If this
7772    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7773    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7774    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7775    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7776    but are not necessarily the same in terms of layout.  */
7777
7778 static void
7779 accumulate_vtbl_inits (tree binfo,
7780                        tree orig_binfo,
7781                        tree rtti_binfo,
7782                        tree vtbl,
7783                        tree t,
7784                        VEC(constructor_elt,gc) **inits)
7785 {
7786   int i;
7787   tree base_binfo;
7788   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7789
7790   gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
7791
7792   /* If it doesn't have a vptr, we don't do anything.  */
7793   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7794     return;
7795
7796   /* If we're building a construction vtable, we're not interested in
7797      subobjects that don't require construction vtables.  */
7798   if (ctor_vtbl_p
7799       && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7800       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7801     return;
7802
7803   /* Build the initializers for the BINFO-in-T vtable.  */
7804   dfs_accumulate_vtbl_inits (binfo, orig_binfo, rtti_binfo, vtbl, t, inits);
7805
7806   /* Walk the BINFO and its bases.  We walk in preorder so that as we
7807      initialize each vtable we can figure out at what offset the
7808      secondary vtable lies from the primary vtable.  We can't use
7809      dfs_walk here because we need to iterate through bases of BINFO
7810      and RTTI_BINFO simultaneously.  */
7811   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7812     {
7813       /* Skip virtual bases.  */
7814       if (BINFO_VIRTUAL_P (base_binfo))
7815         continue;
7816       accumulate_vtbl_inits (base_binfo,
7817                              BINFO_BASE_BINFO (orig_binfo, i),
7818                              rtti_binfo, vtbl, t,
7819                              inits);
7820     }
7821 }
7822
7823 /* Called from accumulate_vtbl_inits.  Adds the initializers for the
7824    BINFO vtable to L.  */
7825
7826 static void
7827 dfs_accumulate_vtbl_inits (tree binfo,
7828                            tree orig_binfo,
7829                            tree rtti_binfo,
7830                            tree orig_vtbl,
7831                            tree t,
7832                            VEC(constructor_elt,gc) **l)
7833 {
7834   tree vtbl = NULL_TREE;
7835   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7836   int n_inits;
7837
7838   if (ctor_vtbl_p
7839       && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7840     {
7841       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7842          primary virtual base.  If it is not the same primary in
7843          the hierarchy of T, we'll need to generate a ctor vtable
7844          for it, to place at its location in T.  If it is the same
7845          primary, we still need a VTT entry for the vtable, but it
7846          should point to the ctor vtable for the base it is a
7847          primary for within the sub-hierarchy of RTTI_BINFO.
7848
7849          There are three possible cases:
7850
7851          1) We are in the same place.
7852          2) We are a primary base within a lost primary virtual base of
7853          RTTI_BINFO.
7854          3) We are primary to something not a base of RTTI_BINFO.  */
7855
7856       tree b;
7857       tree last = NULL_TREE;
7858
7859       /* First, look through the bases we are primary to for RTTI_BINFO
7860          or a virtual base.  */
7861       b = binfo;
7862       while (BINFO_PRIMARY_P (b))
7863         {
7864           b = BINFO_INHERITANCE_CHAIN (b);
7865           last = b;
7866           if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7867             goto found;
7868         }
7869       /* If we run out of primary links, keep looking down our
7870          inheritance chain; we might be an indirect primary.  */
7871       for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7872         if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7873           break;
7874     found:
7875
7876       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7877          base B and it is a base of RTTI_BINFO, this is case 2.  In
7878          either case, we share our vtable with LAST, i.e. the
7879          derived-most base within B of which we are a primary.  */
7880       if (b == rtti_binfo
7881           || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7882         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7883            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7884            binfo_ctor_vtable after everything's been set up.  */
7885         vtbl = last;
7886
7887       /* Otherwise, this is case 3 and we get our own.  */
7888     }
7889   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7890     return;
7891
7892   n_inits = VEC_length (constructor_elt, *l);
7893
7894   if (!vtbl)
7895     {
7896       tree index;
7897       int non_fn_entries;
7898
7899       /* Add the initializer for this vtable.  */
7900       build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7901                               &non_fn_entries, l);
7902
7903       /* Figure out the position to which the VPTR should point.  */
7904       vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, orig_vtbl);
7905       index = size_binop (MULT_EXPR,
7906                           TYPE_SIZE_UNIT (vtable_entry_type),
7907                           size_int (non_fn_entries + n_inits));
7908       vtbl = fold_build_pointer_plus (vtbl, index);
7909     }
7910
7911   if (ctor_vtbl_p)
7912     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7913        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7914        straighten this out.  */
7915     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7916   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7917     /* Throw away any unneeded intializers.  */
7918     VEC_truncate (constructor_elt, *l, n_inits);
7919   else
7920      /* For an ordinary vtable, set BINFO_VTABLE.  */
7921     BINFO_VTABLE (binfo) = vtbl;
7922 }
7923
7924 static GTY(()) tree abort_fndecl_addr;
7925
7926 /* Construct the initializer for BINFO's virtual function table.  BINFO
7927    is part of the hierarchy dominated by T.  If we're building a
7928    construction vtable, the ORIG_BINFO is the binfo we should use to
7929    find the actual function pointers to put in the vtable - but they
7930    can be overridden on the path to most-derived in the graph that
7931    ORIG_BINFO belongs.  Otherwise,
7932    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7933    BINFO that should be indicated by the RTTI information in the
7934    vtable; it will be a base class of T, rather than T itself, if we
7935    are building a construction vtable.
7936
7937    The value returned is a TREE_LIST suitable for wrapping in a
7938    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7939    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7940    number of non-function entries in the vtable.
7941
7942    It might seem that this function should never be called with a
7943    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7944    base is always subsumed by a derived class vtable.  However, when
7945    we are building construction vtables, we do build vtables for
7946    primary bases; we need these while the primary base is being
7947    constructed.  */
7948
7949 static void
7950 build_vtbl_initializer (tree binfo,
7951                         tree orig_binfo,
7952                         tree t,
7953                         tree rtti_binfo,
7954                         int* non_fn_entries_p,
7955                         VEC(constructor_elt,gc) **inits)
7956 {
7957   tree v;
7958   vtbl_init_data vid;
7959   unsigned ix, jx;
7960   tree vbinfo;
7961   VEC(tree,gc) *vbases;
7962   constructor_elt *e;
7963
7964   /* Initialize VID.  */
7965   memset (&vid, 0, sizeof (vid));
7966   vid.binfo = binfo;
7967   vid.derived = t;
7968   vid.rtti_binfo = rtti_binfo;
7969   vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7970   vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7971   vid.generate_vcall_entries = true;
7972   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7973   vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7974
7975   /* Add entries to the vtable for RTTI.  */
7976   build_rtti_vtbl_entries (binfo, &vid);
7977
7978   /* Create an array for keeping track of the functions we've
7979      processed.  When we see multiple functions with the same
7980      signature, we share the vcall offsets.  */
7981   vid.fns = VEC_alloc (tree, gc, 32);
7982   /* Add the vcall and vbase offset entries.  */
7983   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7984
7985   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7986      build_vbase_offset_vtbl_entries.  */
7987   for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7988        VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7989     BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7990
7991   /* If the target requires padding between data entries, add that now.  */
7992   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7993     {
7994       int n_entries = VEC_length (constructor_elt, vid.inits);
7995
7996       VEC_safe_grow (constructor_elt, gc, vid.inits,
7997                      TARGET_VTABLE_DATA_ENTRY_DISTANCE * n_entries);
7998
7999       /* Move data entries into their new positions and add padding
8000          after the new positions.  Iterate backwards so we don't
8001          overwrite entries that we would need to process later.  */
8002       for (ix = n_entries - 1;
8003            VEC_iterate (constructor_elt, vid.inits, ix, e);
8004            ix--)
8005         {
8006           int j;
8007           int new_position = (TARGET_VTABLE_DATA_ENTRY_DISTANCE * ix
8008                               + (TARGET_VTABLE_DATA_ENTRY_DISTANCE - 1));
8009
8010           VEC_replace (constructor_elt, vid.inits, new_position, e);
8011
8012           for (j = 1; j < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++j)
8013             {
8014               constructor_elt *f = VEC_index (constructor_elt, vid.inits,
8015                                               new_position - j);
8016               f->index = NULL_TREE;
8017               f->value = build1 (NOP_EXPR, vtable_entry_type,
8018                                  null_pointer_node);
8019             }
8020         }
8021     }
8022
8023   if (non_fn_entries_p)
8024     *non_fn_entries_p = VEC_length (constructor_elt, vid.inits);
8025
8026   /* The initializers for virtual functions were built up in reverse
8027      order.  Straighten them out and add them to the running list in one
8028      step.  */
8029   jx = VEC_length (constructor_elt, *inits);
8030   VEC_safe_grow (constructor_elt, gc, *inits,
8031                  (jx + VEC_length (constructor_elt, vid.inits)));
8032
8033   for (ix = VEC_length (constructor_elt, vid.inits) - 1;
8034        VEC_iterate (constructor_elt, vid.inits, ix, e);
8035        ix--, jx++)
8036     VEC_replace (constructor_elt, *inits, jx, e);
8037
8038   /* Go through all the ordinary virtual functions, building up
8039      initializers.  */
8040   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
8041     {
8042       tree delta;
8043       tree vcall_index;
8044       tree fn, fn_original;
8045       tree init = NULL_TREE;
8046
8047       fn = BV_FN (v);
8048       fn_original = fn;
8049       if (DECL_THUNK_P (fn))
8050         {
8051           if (!DECL_NAME (fn))
8052             finish_thunk (fn);
8053           if (THUNK_ALIAS (fn))
8054             {
8055               fn = THUNK_ALIAS (fn);
8056               BV_FN (v) = fn;
8057             }
8058           fn_original = THUNK_TARGET (fn);
8059         }
8060
8061       /* If the only definition of this function signature along our
8062          primary base chain is from a lost primary, this vtable slot will
8063          never be used, so just zero it out.  This is important to avoid
8064          requiring extra thunks which cannot be generated with the function.
8065
8066          We first check this in update_vtable_entry_for_fn, so we handle
8067          restored primary bases properly; we also need to do it here so we
8068          zero out unused slots in ctor vtables, rather than filling them
8069          with erroneous values (though harmless, apart from relocation
8070          costs).  */
8071       if (BV_LOST_PRIMARY (v))
8072         init = size_zero_node;
8073
8074       if (! init)
8075         {
8076           /* Pull the offset for `this', and the function to call, out of
8077              the list.  */
8078           delta = BV_DELTA (v);
8079           vcall_index = BV_VCALL_INDEX (v);
8080
8081           gcc_assert (TREE_CODE (delta) == INTEGER_CST);
8082           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
8083
8084           /* You can't call an abstract virtual function; it's abstract.
8085              So, we replace these functions with __pure_virtual.  */
8086           if (DECL_PURE_VIRTUAL_P (fn_original))
8087             {
8088               fn = abort_fndecl;
8089               if (!TARGET_VTABLE_USES_DESCRIPTORS)
8090                 {
8091                   if (abort_fndecl_addr == NULL)
8092                     abort_fndecl_addr
8093                       = fold_convert (vfunc_ptr_type_node,
8094                                       build_fold_addr_expr (fn));
8095                   init = abort_fndecl_addr;
8096                 }
8097             }
8098           else
8099             {
8100               if (!integer_zerop (delta) || vcall_index)
8101                 {
8102                   fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
8103                   if (!DECL_NAME (fn))
8104                     finish_thunk (fn);
8105                 }
8106               /* Take the address of the function, considering it to be of an
8107                  appropriate generic type.  */
8108               if (!TARGET_VTABLE_USES_DESCRIPTORS)
8109                 init = fold_convert (vfunc_ptr_type_node,
8110                                      build_fold_addr_expr (fn));
8111             }
8112         }
8113
8114       /* And add it to the chain of initializers.  */
8115       if (TARGET_VTABLE_USES_DESCRIPTORS)
8116         {
8117           int i;
8118           if (init == size_zero_node)
8119             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
8120               CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
8121           else
8122             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
8123               {
8124                 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
8125                                      fn, build_int_cst (NULL_TREE, i));
8126                 TREE_CONSTANT (fdesc) = 1;
8127
8128                 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, fdesc);
8129               }
8130         }
8131       else
8132         CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
8133     }
8134 }
8135
8136 /* Adds to vid->inits the initializers for the vbase and vcall
8137    offsets in BINFO, which is in the hierarchy dominated by T.  */
8138
8139 static void
8140 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
8141 {
8142   tree b;
8143
8144   /* If this is a derived class, we must first create entries
8145      corresponding to the primary base class.  */
8146   b = get_primary_binfo (binfo);
8147   if (b)
8148     build_vcall_and_vbase_vtbl_entries (b, vid);
8149
8150   /* Add the vbase entries for this base.  */
8151   build_vbase_offset_vtbl_entries (binfo, vid);
8152   /* Add the vcall entries for this base.  */
8153   build_vcall_offset_vtbl_entries (binfo, vid);
8154 }
8155
8156 /* Returns the initializers for the vbase offset entries in the vtable
8157    for BINFO (which is part of the class hierarchy dominated by T), in
8158    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
8159    where the next vbase offset will go.  */
8160
8161 static void
8162 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
8163 {
8164   tree vbase;
8165   tree t;
8166   tree non_primary_binfo;
8167
8168   /* If there are no virtual baseclasses, then there is nothing to
8169      do.  */
8170   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
8171     return;
8172
8173   t = vid->derived;
8174
8175   /* We might be a primary base class.  Go up the inheritance hierarchy
8176      until we find the most derived class of which we are a primary base:
8177      it is the offset of that which we need to use.  */
8178   non_primary_binfo = binfo;
8179   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
8180     {
8181       tree b;
8182
8183       /* If we have reached a virtual base, then it must be a primary
8184          base (possibly multi-level) of vid->binfo, or we wouldn't
8185          have called build_vcall_and_vbase_vtbl_entries for it.  But it
8186          might be a lost primary, so just skip down to vid->binfo.  */
8187       if (BINFO_VIRTUAL_P (non_primary_binfo))
8188         {
8189           non_primary_binfo = vid->binfo;
8190           break;
8191         }
8192
8193       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
8194       if (get_primary_binfo (b) != non_primary_binfo)
8195         break;
8196       non_primary_binfo = b;
8197     }
8198
8199   /* Go through the virtual bases, adding the offsets.  */
8200   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
8201        vbase;
8202        vbase = TREE_CHAIN (vbase))
8203     {
8204       tree b;
8205       tree delta;
8206
8207       if (!BINFO_VIRTUAL_P (vbase))
8208         continue;
8209
8210       /* Find the instance of this virtual base in the complete
8211          object.  */
8212       b = copied_binfo (vbase, binfo);
8213
8214       /* If we've already got an offset for this virtual base, we
8215          don't need another one.  */
8216       if (BINFO_VTABLE_PATH_MARKED (b))
8217         continue;
8218       BINFO_VTABLE_PATH_MARKED (b) = 1;
8219
8220       /* Figure out where we can find this vbase offset.  */
8221       delta = size_binop (MULT_EXPR,
8222                           vid->index,
8223                           convert (ssizetype,
8224                                    TYPE_SIZE_UNIT (vtable_entry_type)));
8225       if (vid->primary_vtbl_p)
8226         BINFO_VPTR_FIELD (b) = delta;
8227
8228       if (binfo != TYPE_BINFO (t))
8229         /* The vbase offset had better be the same.  */
8230         gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
8231
8232       /* The next vbase will come at a more negative offset.  */
8233       vid->index = size_binop (MINUS_EXPR, vid->index,
8234                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
8235
8236       /* The initializer is the delta from BINFO to this virtual base.
8237          The vbase offsets go in reverse inheritance-graph order, and
8238          we are walking in inheritance graph order so these end up in
8239          the right order.  */
8240       delta = size_diffop_loc (input_location,
8241                            BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
8242
8243       CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE,
8244                               fold_build1_loc (input_location, NOP_EXPR,
8245                                                vtable_entry_type, delta));
8246     }
8247 }
8248
8249 /* Adds the initializers for the vcall offset entries in the vtable
8250    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
8251    to VID->INITS.  */
8252
8253 static void
8254 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
8255 {
8256   /* We only need these entries if this base is a virtual base.  We
8257      compute the indices -- but do not add to the vtable -- when
8258      building the main vtable for a class.  */
8259   if (binfo == TYPE_BINFO (vid->derived)
8260       || (BINFO_VIRTUAL_P (binfo)
8261           /* If BINFO is RTTI_BINFO, then (since BINFO does not
8262              correspond to VID->DERIVED), we are building a primary
8263              construction virtual table.  Since this is a primary
8264              virtual table, we do not need the vcall offsets for
8265              BINFO.  */
8266           && binfo != vid->rtti_binfo))
8267     {
8268       /* We need a vcall offset for each of the virtual functions in this
8269          vtable.  For example:
8270
8271            class A { virtual void f (); };
8272            class B1 : virtual public A { virtual void f (); };
8273            class B2 : virtual public A { virtual void f (); };
8274            class C: public B1, public B2 { virtual void f (); };
8275
8276          A C object has a primary base of B1, which has a primary base of A.  A
8277          C also has a secondary base of B2, which no longer has a primary base
8278          of A.  So the B2-in-C construction vtable needs a secondary vtable for
8279          A, which will adjust the A* to a B2* to call f.  We have no way of
8280          knowing what (or even whether) this offset will be when we define B2,
8281          so we store this "vcall offset" in the A sub-vtable and look it up in
8282          a "virtual thunk" for B2::f.
8283
8284          We need entries for all the functions in our primary vtable and
8285          in our non-virtual bases' secondary vtables.  */
8286       vid->vbase = binfo;
8287       /* If we are just computing the vcall indices -- but do not need
8288          the actual entries -- not that.  */
8289       if (!BINFO_VIRTUAL_P (binfo))
8290         vid->generate_vcall_entries = false;
8291       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
8292       add_vcall_offset_vtbl_entries_r (binfo, vid);
8293     }
8294 }
8295
8296 /* Build vcall offsets, starting with those for BINFO.  */
8297
8298 static void
8299 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
8300 {
8301   int i;
8302   tree primary_binfo;
8303   tree base_binfo;
8304
8305   /* Don't walk into virtual bases -- except, of course, for the
8306      virtual base for which we are building vcall offsets.  Any
8307      primary virtual base will have already had its offsets generated
8308      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
8309   if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
8310     return;
8311
8312   /* If BINFO has a primary base, process it first.  */
8313   primary_binfo = get_primary_binfo (binfo);
8314   if (primary_binfo)
8315     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
8316
8317   /* Add BINFO itself to the list.  */
8318   add_vcall_offset_vtbl_entries_1 (binfo, vid);
8319
8320   /* Scan the non-primary bases of BINFO.  */
8321   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
8322     if (base_binfo != primary_binfo)
8323       add_vcall_offset_vtbl_entries_r (base_binfo, vid);
8324 }
8325
8326 /* Called from build_vcall_offset_vtbl_entries_r.  */
8327
8328 static void
8329 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
8330 {
8331   /* Make entries for the rest of the virtuals.  */
8332   if (abi_version_at_least (2))
8333     {
8334       tree orig_fn;
8335
8336       /* The ABI requires that the methods be processed in declaration
8337          order.  G++ 3.2 used the order in the vtable.  */
8338       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
8339            orig_fn;
8340            orig_fn = DECL_CHAIN (orig_fn))
8341         if (DECL_VINDEX (orig_fn))
8342           add_vcall_offset (orig_fn, binfo, vid);
8343     }
8344   else
8345     {
8346       tree derived_virtuals;
8347       tree base_virtuals;
8348       tree orig_virtuals;
8349       /* If BINFO is a primary base, the most derived class which has
8350          BINFO as a primary base; otherwise, just BINFO.  */
8351       tree non_primary_binfo;
8352
8353       /* We might be a primary base class.  Go up the inheritance hierarchy
8354          until we find the most derived class of which we are a primary base:
8355          it is the BINFO_VIRTUALS there that we need to consider.  */
8356       non_primary_binfo = binfo;
8357       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
8358         {
8359           tree b;
8360
8361           /* If we have reached a virtual base, then it must be vid->vbase,
8362              because we ignore other virtual bases in
8363              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
8364              base (possibly multi-level) of vid->binfo, or we wouldn't
8365              have called build_vcall_and_vbase_vtbl_entries for it.  But it
8366              might be a lost primary, so just skip down to vid->binfo.  */
8367           if (BINFO_VIRTUAL_P (non_primary_binfo))
8368             {
8369               gcc_assert (non_primary_binfo == vid->vbase);
8370               non_primary_binfo = vid->binfo;
8371               break;
8372             }
8373
8374           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
8375           if (get_primary_binfo (b) != non_primary_binfo)
8376             break;
8377           non_primary_binfo = b;
8378         }
8379
8380       if (vid->ctor_vtbl_p)
8381         /* For a ctor vtable we need the equivalent binfo within the hierarchy
8382            where rtti_binfo is the most derived type.  */
8383         non_primary_binfo
8384           = original_binfo (non_primary_binfo, vid->rtti_binfo);
8385
8386       for (base_virtuals = BINFO_VIRTUALS (binfo),
8387              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
8388              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
8389            base_virtuals;
8390            base_virtuals = TREE_CHAIN (base_virtuals),
8391              derived_virtuals = TREE_CHAIN (derived_virtuals),
8392              orig_virtuals = TREE_CHAIN (orig_virtuals))
8393         {
8394           tree orig_fn;
8395
8396           /* Find the declaration that originally caused this function to
8397              be present in BINFO_TYPE (binfo).  */
8398           orig_fn = BV_FN (orig_virtuals);
8399
8400           /* When processing BINFO, we only want to generate vcall slots for
8401              function slots introduced in BINFO.  So don't try to generate
8402              one if the function isn't even defined in BINFO.  */
8403           if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
8404             continue;
8405
8406           add_vcall_offset (orig_fn, binfo, vid);
8407         }
8408     }
8409 }
8410
8411 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
8412
8413 static void
8414 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
8415 {
8416   size_t i;
8417   tree vcall_offset;
8418   tree derived_entry;
8419
8420   /* If there is already an entry for a function with the same
8421      signature as FN, then we do not need a second vcall offset.
8422      Check the list of functions already present in the derived
8423      class vtable.  */
8424   FOR_EACH_VEC_ELT (tree, vid->fns, i, derived_entry)
8425     {
8426       if (same_signature_p (derived_entry, orig_fn)
8427           /* We only use one vcall offset for virtual destructors,
8428              even though there are two virtual table entries.  */
8429           || (DECL_DESTRUCTOR_P (derived_entry)
8430               && DECL_DESTRUCTOR_P (orig_fn)))
8431         return;
8432     }
8433
8434   /* If we are building these vcall offsets as part of building
8435      the vtable for the most derived class, remember the vcall
8436      offset.  */
8437   if (vid->binfo == TYPE_BINFO (vid->derived))
8438     {
8439       tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
8440                                        CLASSTYPE_VCALL_INDICES (vid->derived),
8441                                        NULL);
8442       elt->purpose = orig_fn;
8443       elt->value = vid->index;
8444     }
8445
8446   /* The next vcall offset will be found at a more negative
8447      offset.  */
8448   vid->index = size_binop (MINUS_EXPR, vid->index,
8449                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
8450
8451   /* Keep track of this function.  */
8452   VEC_safe_push (tree, gc, vid->fns, orig_fn);
8453
8454   if (vid->generate_vcall_entries)
8455     {
8456       tree base;
8457       tree fn;
8458
8459       /* Find the overriding function.  */
8460       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
8461       if (fn == error_mark_node)
8462         vcall_offset = build_zero_cst (vtable_entry_type);
8463       else
8464         {
8465           base = TREE_VALUE (fn);
8466
8467           /* The vbase we're working on is a primary base of
8468              vid->binfo.  But it might be a lost primary, so its
8469              BINFO_OFFSET might be wrong, so we just use the
8470              BINFO_OFFSET from vid->binfo.  */
8471           vcall_offset = size_diffop_loc (input_location,
8472                                       BINFO_OFFSET (base),
8473                                       BINFO_OFFSET (vid->binfo));
8474           vcall_offset = fold_build1_loc (input_location,
8475                                       NOP_EXPR, vtable_entry_type,
8476                                       vcall_offset);
8477         }
8478       /* Add the initializer to the vtable.  */
8479       CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, vcall_offset);
8480     }
8481 }
8482
8483 /* Return vtbl initializers for the RTTI entries corresponding to the
8484    BINFO's vtable.  The RTTI entries should indicate the object given
8485    by VID->rtti_binfo.  */
8486
8487 static void
8488 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
8489 {
8490   tree b;
8491   tree t;
8492   tree offset;
8493   tree decl;
8494   tree init;
8495
8496   t = BINFO_TYPE (vid->rtti_binfo);
8497
8498   /* To find the complete object, we will first convert to our most
8499      primary base, and then add the offset in the vtbl to that value.  */
8500   b = binfo;
8501   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
8502          && !BINFO_LOST_PRIMARY_P (b))
8503     {
8504       tree primary_base;
8505
8506       primary_base = get_primary_binfo (b);
8507       gcc_assert (BINFO_PRIMARY_P (primary_base)
8508                   && BINFO_INHERITANCE_CHAIN (primary_base) == b);
8509       b = primary_base;
8510     }
8511   offset = size_diffop_loc (input_location,
8512                         BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
8513
8514   /* The second entry is the address of the typeinfo object.  */
8515   if (flag_rtti)
8516     decl = build_address (get_tinfo_decl (t));
8517   else
8518     decl = integer_zero_node;
8519
8520   /* Convert the declaration to a type that can be stored in the
8521      vtable.  */
8522   init = build_nop (vfunc_ptr_type_node, decl);
8523   CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
8524
8525   /* Add the offset-to-top entry.  It comes earlier in the vtable than
8526      the typeinfo entry.  Convert the offset to look like a
8527      function pointer, so that we can put it in the vtable.  */
8528   init = build_nop (vfunc_ptr_type_node, offset);
8529   CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
8530 }
8531
8532 #include "gt-cp-class.h"