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