gcc/cp/class.c

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