gcc/cp/class.c

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