gcc/cp/class.c

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