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 (least_bit_hwi (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 (least_bit_hwi (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 if FN is a default constructor.  */
5137
5138 bool
5139 default_ctor_p (tree fn)
5140 {
5141   return (DECL_CONSTRUCTOR_P (fn)
5142           && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn)));
5143 }
5144
5145 /* Returns true iff class T has a user-defined constructor that can be called
5146    with more than zero arguments.  */
5147
5148 bool
5149 type_has_user_nondefault_constructor (tree t)
5150 {
5151   tree fns;
5152
5153   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
5154     return false;
5155
5156   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
5157     {
5158       tree fn = OVL_CURRENT (fns);
5159       if (!DECL_ARTIFICIAL (fn)
5160           && (TREE_CODE (fn) == TEMPLATE_DECL
5161               || (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn))
5162                   != NULL_TREE)))
5163         return true;
5164     }
5165
5166   return false;
5167 }
5168
5169 /* Returns the defaulted constructor if T has one. Otherwise, returns
5170    NULL_TREE.  */
5171
5172 tree
5173 in_class_defaulted_default_constructor (tree t)
5174 {
5175   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
5176     return NULL_TREE;
5177
5178   for (tree fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
5179     {
5180       tree fn = OVL_CURRENT (fns);
5181
5182       if (DECL_DEFAULTED_IN_CLASS_P (fn)
5183           && default_ctor_p (fn))
5184         return fn;
5185     }
5186
5187   return NULL_TREE;
5188 }
5189
5190 /* Returns true iff FN is a user-provided function, i.e. user-declared
5191    and not defaulted at its first declaration.  */
5192
5193 bool
5194 user_provided_p (tree fn)
5195 {
5196   if (TREE_CODE (fn) == TEMPLATE_DECL)
5197     return true;
5198   else
5199     return (!DECL_ARTIFICIAL (fn)
5200             && !(DECL_INITIALIZED_IN_CLASS_P (fn)
5201                  && (DECL_DEFAULTED_FN (fn) || DECL_DELETED_FN (fn))));
5202 }
5203
5204 /* Returns true iff class T has a user-provided constructor.  */
5205
5206 bool
5207 type_has_user_provided_constructor (tree t)
5208 {
5209   tree fns;
5210
5211   if (!CLASS_TYPE_P (t))
5212     return false;
5213
5214   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
5215     return false;
5216
5217   /* This can happen in error cases; avoid crashing.  */
5218   if (!CLASSTYPE_METHOD_VEC (t))
5219     return false;
5220
5221   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
5222     if (user_provided_p (OVL_CURRENT (fns)))
5223       return true;
5224
5225   return false;
5226 }
5227
5228 /* Returns true iff class T has a user-provided or explicit constructor.  */
5229
5230 bool
5231 type_has_user_provided_or_explicit_constructor (tree t)
5232 {
5233   tree fns;
5234
5235   if (!CLASS_TYPE_P (t))
5236     return false;
5237
5238   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
5239     return false;
5240
5241   /* This can happen in error cases; avoid crashing.  */
5242   if (!CLASSTYPE_METHOD_VEC (t))
5243     return false;
5244
5245   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
5246     {
5247       tree fn = OVL_CURRENT (fns);
5248       if (user_provided_p (fn) || DECL_NONCONVERTING_P (fn))
5249         return true;
5250     }
5251
5252   return false;
5253 }
5254
5255 /* Returns true iff class T has a non-user-provided (i.e. implicitly
5256    declared or explicitly defaulted in the class body) default
5257    constructor.  */
5258
5259 bool
5260 type_has_non_user_provided_default_constructor (tree t)
5261 {
5262   tree fns;
5263
5264   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (t))
5265     return false;
5266   if (CLASSTYPE_LAZY_DEFAULT_CTOR (t))
5267     return true;
5268
5269   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
5270     {
5271       tree fn = OVL_CURRENT (fns);
5272       if (TREE_CODE (fn) == FUNCTION_DECL
5273           && default_ctor_p (fn)
5274           && !user_provided_p (fn))
5275         return true;
5276     }
5277
5278   return false;
5279 }
5280
5281 /* TYPE is being used as a virtual base, and has a non-trivial move
5282    assignment.  Return true if this is due to there being a user-provided
5283    move assignment in TYPE or one of its subobjects; if there isn't, then
5284    multiple move assignment can't cause any harm.  */
5285
5286 bool
5287 vbase_has_user_provided_move_assign (tree type)
5288 {
5289   /* Does the type itself have a user-provided move assignment operator?  */
5290   for (tree fns
5291          = lookup_fnfields_slot_nolazy (type, ansi_assopname (NOP_EXPR));
5292        fns; fns = OVL_NEXT (fns))
5293     {
5294       tree fn = OVL_CURRENT (fns);
5295       if (move_fn_p (fn) && user_provided_p (fn))
5296         return true;
5297     }
5298
5299   /* Do any of its bases?  */
5300   tree binfo = TYPE_BINFO (type);
5301   tree base_binfo;
5302   for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
5303     if (vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo)))
5304       return true;
5305
5306   /* Or non-static data members?  */
5307   for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5308     {
5309       if (TREE_CODE (field) == FIELD_DECL
5310           && CLASS_TYPE_P (TREE_TYPE (field))
5311           && vbase_has_user_provided_move_assign (TREE_TYPE (field)))
5312         return true;
5313     }
5314
5315   /* Seems not.  */
5316   return false;
5317 }
5318
5319 /* If default-initialization leaves part of TYPE uninitialized, returns
5320    a DECL for the field or TYPE itself (DR 253).  */
5321
5322 tree
5323 default_init_uninitialized_part (tree type)
5324 {
5325   tree t, r, binfo;
5326   int i;
5327
5328   type = strip_array_types (type);
5329   if (!CLASS_TYPE_P (type))
5330     return type;
5331   if (!type_has_non_user_provided_default_constructor (type))
5332     return NULL_TREE;
5333   for (binfo = TYPE_BINFO (type), i = 0;
5334        BINFO_BASE_ITERATE (binfo, i, t); ++i)
5335     {
5336       r = default_init_uninitialized_part (BINFO_TYPE (t));
5337       if (r)
5338         return r;
5339     }
5340   for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
5341     if (TREE_CODE (t) == FIELD_DECL
5342         && !DECL_ARTIFICIAL (t)
5343         && !DECL_INITIAL (t))
5344       {
5345         r = default_init_uninitialized_part (TREE_TYPE (t));
5346         if (r)
5347           return DECL_P (r) ? r : t;
5348       }
5349
5350   return NULL_TREE;
5351 }
5352
5353 /* Returns true iff for class T, a trivial synthesized default constructor
5354    would be constexpr.  */
5355
5356 bool
5357 trivial_default_constructor_is_constexpr (tree t)
5358 {
5359   /* A defaulted trivial default constructor is constexpr
5360      if there is nothing to initialize.  */
5361   gcc_assert (!TYPE_HAS_COMPLEX_DFLT (t));
5362   return is_really_empty_class (t);
5363 }
5364
5365 /* Returns true iff class T has a constexpr default constructor.  */
5366
5367 bool
5368 type_has_constexpr_default_constructor (tree t)
5369 {
5370   tree fns;
5371
5372   if (!CLASS_TYPE_P (t))
5373     {
5374       /* The caller should have stripped an enclosing array.  */
5375       gcc_assert (TREE_CODE (t) != ARRAY_TYPE);
5376       return false;
5377     }
5378   if (CLASSTYPE_LAZY_DEFAULT_CTOR (t))
5379     {
5380       if (!TYPE_HAS_COMPLEX_DFLT (t))
5381         return trivial_default_constructor_is_constexpr (t);
5382       /* Non-trivial, we need to check subobject constructors.  */
5383       lazily_declare_fn (sfk_constructor, t);
5384     }
5385   fns = locate_ctor (t);
5386   return (fns && DECL_DECLARED_CONSTEXPR_P (fns));
5387 }
5388
5389 /* Returns true iff class T has a constexpr default constructor or has an
5390    implicitly declared default constructor that we can't tell if it's constexpr
5391    without forcing a lazy declaration (which might cause undesired
5392    instantiations).  */
5393
5394 bool
5395 type_maybe_constexpr_default_constructor (tree t)
5396 {
5397   if (CLASS_TYPE_P (t) && CLASSTYPE_LAZY_DEFAULT_CTOR (t)
5398       && TYPE_HAS_COMPLEX_DFLT (t))
5399     /* Assume it's constexpr.  */
5400     return true;
5401   return type_has_constexpr_default_constructor (t);
5402 }
5403
5404 /* Returns true iff class TYPE has a virtual destructor.  */
5405
5406 bool
5407 type_has_virtual_destructor (tree type)
5408 {
5409   tree dtor;
5410
5411   if (!CLASS_TYPE_P (type))
5412     return false;
5413
5414   gcc_assert (COMPLETE_TYPE_P (type));
5415   dtor = CLASSTYPE_DESTRUCTORS (type);
5416   return (dtor && DECL_VIRTUAL_P (dtor));
5417 }
5418
5419 /* Returns true iff class T has a move constructor.  */
5420
5421 bool
5422 type_has_move_constructor (tree t)
5423 {
5424   tree fns;
5425
5426   if (CLASSTYPE_LAZY_MOVE_CTOR (t))
5427     {
5428       gcc_assert (COMPLETE_TYPE_P (t));
5429       lazily_declare_fn (sfk_move_constructor, t);
5430     }
5431
5432   if (!CLASSTYPE_METHOD_VEC (t))
5433     return false;
5434
5435   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
5436     if (move_fn_p (OVL_CURRENT (fns)))
5437       return true;
5438
5439   return false;
5440 }
5441
5442 /* Returns true iff class T has a move assignment operator.  */
5443
5444 bool
5445 type_has_move_assign (tree t)
5446 {
5447   tree fns;
5448
5449   if (CLASSTYPE_LAZY_MOVE_ASSIGN (t))
5450     {
5451       gcc_assert (COMPLETE_TYPE_P (t));
5452       lazily_declare_fn (sfk_move_assignment, t);
5453     }
5454
5455   for (fns = lookup_fnfields_slot_nolazy (t, ansi_assopname (NOP_EXPR));
5456        fns; fns = OVL_NEXT (fns))
5457     if (move_fn_p (OVL_CURRENT (fns)))
5458       return true;
5459
5460   return false;
5461 }
5462
5463 /* Returns true iff class T has a move constructor that was explicitly
5464    declared in the class body.  Note that this is different from
5465    "user-provided", which doesn't include functions that are defaulted in
5466    the class.  */
5467
5468 bool
5469 type_has_user_declared_move_constructor (tree t)
5470 {
5471   tree fns;
5472
5473   if (CLASSTYPE_LAZY_MOVE_CTOR (t))
5474     return false;
5475
5476   if (!CLASSTYPE_METHOD_VEC (t))
5477     return false;
5478
5479   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
5480     {
5481       tree fn = OVL_CURRENT (fns);
5482       if (move_fn_p (fn) && !DECL_ARTIFICIAL (fn))
5483         return true;
5484     }
5485
5486   return false;
5487 }
5488
5489 /* Returns true iff class T has a move assignment operator that was
5490    explicitly declared in the class body.  */
5491
5492 bool
5493 type_has_user_declared_move_assign (tree t)
5494 {
5495   tree fns;
5496
5497   if (CLASSTYPE_LAZY_MOVE_ASSIGN (t))
5498     return false;
5499
5500   for (fns = lookup_fnfields_slot_nolazy (t, ansi_assopname (NOP_EXPR));
5501        fns; fns = OVL_NEXT (fns))
5502     {
5503       tree fn = OVL_CURRENT (fns);
5504       if (move_fn_p (fn) && !DECL_ARTIFICIAL (fn))
5505         return true;
5506     }
5507
5508   return false;
5509 }
5510
5511 /* Nonzero if we need to build up a constructor call when initializing an
5512    object of this class, either because it has a user-declared constructor
5513    or because it doesn't have a default constructor (so we need to give an
5514    error if no initializer is provided).  Use TYPE_NEEDS_CONSTRUCTING when
5515    what you care about is whether or not an object can be produced by a
5516    constructor (e.g. so we don't set TREE_READONLY on const variables of
5517    such type); use this function when what you care about is whether or not
5518    to try to call a constructor to create an object.  The latter case is
5519    the former plus some cases of constructors that cannot be called.  */
5520
5521 bool
5522 type_build_ctor_call (tree t)
5523 {
5524   tree inner;
5525   if (TYPE_NEEDS_CONSTRUCTING (t))
5526     return true;
5527   inner = strip_array_types (t);
5528   if (!CLASS_TYPE_P (inner) || ANON_AGGR_TYPE_P (inner))
5529     return false;
5530   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (inner))
5531     return true;
5532   if (cxx_dialect < cxx11)
5533     return false;
5534   /* A user-declared constructor might be private, and a constructor might
5535      be trivial but deleted.  */
5536   for (tree fns = lookup_fnfields_slot (inner, complete_ctor_identifier);
5537        fns; fns = OVL_NEXT (fns))
5538     {
5539       tree fn = OVL_CURRENT (fns);
5540       if (!DECL_ARTIFICIAL (fn)
5541           || DECL_DELETED_FN (fn))
5542         return true;
5543     }
5544   return false;
5545 }
5546
5547 /* Like type_build_ctor_call, but for destructors.  */
5548
5549 bool
5550 type_build_dtor_call (tree t)
5551 {
5552   tree inner;
5553   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
5554     return true;
5555   inner = strip_array_types (t);
5556   if (!CLASS_TYPE_P (inner) || ANON_AGGR_TYPE_P (inner)
5557       || !COMPLETE_TYPE_P (inner))
5558     return false;
5559   if (cxx_dialect < cxx11)
5560     return false;
5561   /* A user-declared destructor might be private, and a destructor might
5562      be trivial but deleted.  */
5563   for (tree fns = lookup_fnfields_slot (inner, complete_dtor_identifier);
5564        fns; fns = OVL_NEXT (fns))
5565     {
5566       tree fn = OVL_CURRENT (fns);
5567       if (!DECL_ARTIFICIAL (fn)
5568           || DECL_DELETED_FN (fn))
5569         return true;
5570     }
5571   return false;
5572 }
5573
5574 /* Remove all zero-width bit-fields from T.  */
5575
5576 static void
5577 remove_zero_width_bit_fields (tree t)
5578 {
5579   tree *fieldsp;
5580
5581   fieldsp = &TYPE_FIELDS (t);
5582   while (*fieldsp)
5583     {
5584       if (TREE_CODE (*fieldsp) == FIELD_DECL
5585           && DECL_C_BIT_FIELD (*fieldsp)
5586           /* We should not be confused by the fact that grokbitfield
5587              temporarily sets the width of the bit field into
5588              DECL_INITIAL (*fieldsp).
5589              check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
5590              to that width.  */
5591           && (DECL_SIZE (*fieldsp) == NULL_TREE
5592               || integer_zerop (DECL_SIZE (*fieldsp))))
5593         *fieldsp = DECL_CHAIN (*fieldsp);
5594       else
5595         fieldsp = &DECL_CHAIN (*fieldsp);
5596     }
5597 }
5598
5599 /* Returns TRUE iff we need a cookie when dynamically allocating an
5600    array whose elements have the indicated class TYPE.  */
5601
5602 static bool
5603 type_requires_array_cookie (tree type)
5604 {
5605   tree fns;
5606   bool has_two_argument_delete_p = false;
5607
5608   gcc_assert (CLASS_TYPE_P (type));
5609
5610   /* If there's a non-trivial destructor, we need a cookie.  In order
5611      to iterate through the array calling the destructor for each
5612      element, we'll have to know how many elements there are.  */
5613   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
5614     return true;
5615
5616   /* If the usual deallocation function is a two-argument whose second
5617      argument is of type `size_t', then we have to pass the size of
5618      the array to the deallocation function, so we will need to store
5619      a cookie.  */
5620   fns = lookup_fnfields (TYPE_BINFO (type),
5621                          ansi_opname (VEC_DELETE_EXPR),
5622                          /*protect=*/0);
5623   /* If there are no `operator []' members, or the lookup is
5624      ambiguous, then we don't need a cookie.  */
5625   if (!fns || fns == error_mark_node)
5626     return false;
5627   /* Loop through all of the functions.  */
5628   for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
5629     {
5630       tree fn;
5631       tree second_parm;
5632
5633       /* Select the current function.  */
5634       fn = OVL_CURRENT (fns);
5635       /* See if this function is a one-argument delete function.  If
5636          it is, then it will be the usual deallocation function.  */
5637       second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
5638       if (second_parm == void_list_node)
5639         return false;
5640       /* Do not consider this function if its second argument is an
5641          ellipsis.  */
5642       if (!second_parm)
5643         continue;
5644       /* Otherwise, if we have a two-argument function and the second
5645          argument is `size_t', it will be the usual deallocation
5646          function -- unless there is one-argument function, too.  */
5647       if (TREE_CHAIN (second_parm) == void_list_node
5648           && same_type_p (TREE_VALUE (second_parm), size_type_node))
5649         has_two_argument_delete_p = true;
5650     }
5651
5652   return has_two_argument_delete_p;
5653 }
5654
5655 /* Finish computing the `literal type' property of class type T.
5656
5657    At this point, we have already processed base classes and
5658    non-static data members.  We need to check whether the copy
5659    constructor is trivial, the destructor is trivial, and there
5660    is a trivial default constructor or at least one constexpr
5661    constructor other than the copy constructor.  */
5662
5663 static void
5664 finalize_literal_type_property (tree t)
5665 {
5666   tree fn;
5667
5668   if (cxx_dialect < cxx11
5669       || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
5670     CLASSTYPE_LITERAL_P (t) = false;
5671   else if (CLASSTYPE_LITERAL_P (t) && !TYPE_HAS_TRIVIAL_DFLT (t)
5672            && CLASSTYPE_NON_AGGREGATE (t)
5673            && !TYPE_HAS_CONSTEXPR_CTOR (t))
5674     CLASSTYPE_LITERAL_P (t) = false;
5675
5676   if (!CLASSTYPE_LITERAL_P (t))
5677     for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
5678       if (DECL_DECLARED_CONSTEXPR_P (fn)
5679           && TREE_CODE (fn) != TEMPLATE_DECL
5680           && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
5681           && !DECL_CONSTRUCTOR_P (fn))
5682         {
5683           DECL_DECLARED_CONSTEXPR_P (fn) = false;
5684           if (!DECL_GENERATED_P (fn) && !LAMBDA_TYPE_P (t))
5685             {
5686               error ("enclosing class of constexpr non-static member "
5687                      "function %q+#D is not a literal type", fn);
5688               explain_non_literal_class (t);
5689             }
5690         }
5691 }
5692
5693 /* T is a non-literal type used in a context which requires a constant
5694    expression.  Explain why it isn't literal.  */
5695
5696 void
5697 explain_non_literal_class (tree t)
5698 {
5699   static hash_set<tree> *diagnosed;
5700
5701   if (!CLASS_TYPE_P (t))
5702     return;
5703   t = TYPE_MAIN_VARIANT (t);
5704
5705   if (diagnosed == NULL)
5706     diagnosed = new hash_set<tree>;
5707   if (diagnosed->add (t))
5708     /* Already explained.  */
5709     return;
5710
5711   inform (0, "%q+T is not literal because:", t);
5712   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
5713     inform (0, "  %q+T has a non-trivial destructor", t);
5714   else if (CLASSTYPE_NON_AGGREGATE (t)
5715            && !TYPE_HAS_TRIVIAL_DFLT (t)
5716            && !TYPE_HAS_CONSTEXPR_CTOR (t))
5717     {
5718       inform (0, "  %q+T is not an aggregate, does not have a trivial "
5719               "default constructor, and has no constexpr constructor that "
5720               "is not a copy or move constructor", t);
5721       if (type_has_non_user_provided_default_constructor (t))
5722         {
5723           /* Note that we can't simply call locate_ctor because when the
5724              constructor is deleted it just returns NULL_TREE.  */
5725           tree fns;
5726           for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
5727             {
5728               tree fn = OVL_CURRENT (fns);
5729               tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
5730
5731               parms = skip_artificial_parms_for (fn, parms);
5732
5733               if (sufficient_parms_p (parms))
5734                 {
5735                   if (DECL_DELETED_FN (fn))
5736                     maybe_explain_implicit_delete (fn);
5737                   else
5738                     explain_invalid_constexpr_fn (fn);
5739                   break;
5740                 }
5741             }
5742         }
5743     }
5744   else
5745     {
5746       tree binfo, base_binfo, field; int i;
5747       for (binfo = TYPE_BINFO (t), i = 0;
5748            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
5749         {
5750           tree basetype = TREE_TYPE (base_binfo);
5751           if (!CLASSTYPE_LITERAL_P (basetype))
5752             {
5753               inform (0, "  base class %qT of %q+T is non-literal",
5754                       basetype, t);
5755               explain_non_literal_class (basetype);
5756               return;
5757             }
5758         }
5759       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
5760         {
5761           tree ftype;
5762           if (TREE_CODE (field) != FIELD_DECL)
5763             continue;
5764           ftype = TREE_TYPE (field);
5765           if (!literal_type_p (ftype))
5766             {
5767               inform (DECL_SOURCE_LOCATION (field),
5768                       "  non-static data member %qD has non-literal type",
5769                       field);
5770               if (CLASS_TYPE_P (ftype))
5771                 explain_non_literal_class (ftype);
5772             }
5773           if (CP_TYPE_VOLATILE_P (ftype))
5774             inform (DECL_SOURCE_LOCATION (field),
5775                     "  non-static data member %qD has volatile type", field);
5776         }
5777     }
5778 }
5779
5780 /* Check the validity of the bases and members declared in T.  Add any
5781    implicitly-generated functions (like copy-constructors and
5782    assignment operators).  Compute various flag bits (like
5783    CLASSTYPE_NON_LAYOUT_POD_T) for T.  This routine works purely at the C++
5784    level: i.e., independently of the ABI in use.  */
5785
5786 static void
5787 check_bases_and_members (tree t)
5788 {
5789   /* Nonzero if the implicitly generated copy constructor should take
5790      a non-const reference argument.  */
5791   int cant_have_const_ctor;
5792   /* Nonzero if the implicitly generated assignment operator
5793      should take a non-const reference argument.  */
5794   int no_const_asn_ref;
5795   tree access_decls;
5796   bool saved_complex_asn_ref;
5797   bool saved_nontrivial_dtor;
5798   tree fn;
5799
5800   /* By default, we use const reference arguments and generate default
5801      constructors.  */
5802   cant_have_const_ctor = 0;
5803   no_const_asn_ref = 0;
5804
5805   /* Check all the base-classes and set FMEM members to point to arrays
5806      of potential interest.  */
5807   check_bases (t, &cant_have_const_ctor, &no_const_asn_ref);
5808
5809   /* Deduce noexcept on destructors.  This needs to happen after we've set
5810      triviality flags appropriately for our bases.  */
5811   if (cxx_dialect >= cxx11)
5812     deduce_noexcept_on_destructors (t);
5813
5814   /* Check all the method declarations.  */
5815   check_methods (t);
5816
5817   /* Save the initial values of these flags which only indicate whether
5818      or not the class has user-provided functions.  As we analyze the
5819      bases and members we can set these flags for other reasons.  */
5820   saved_complex_asn_ref = TYPE_HAS_COMPLEX_COPY_ASSIGN (t);
5821   saved_nontrivial_dtor = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
5822
5823   /* Check all the data member declarations.  We cannot call
5824      check_field_decls until we have called check_bases check_methods,
5825      as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5826      being set appropriately.  */
5827   check_field_decls (t, &access_decls,
5828                      &cant_have_const_ctor,
5829                      &no_const_asn_ref);
5830
5831   /* A nearly-empty class has to be vptr-containing; a nearly empty
5832      class contains just a vptr.  */
5833   if (!TYPE_CONTAINS_VPTR_P (t))
5834     CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
5835
5836   /* Do some bookkeeping that will guide the generation of implicitly
5837      declared member functions.  */
5838   TYPE_HAS_COMPLEX_COPY_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t);
5839   TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t);
5840   /* We need to call a constructor for this class if it has a
5841      user-provided constructor, or if the default constructor is going
5842      to initialize the vptr.  (This is not an if-and-only-if;
5843      TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
5844      themselves need constructing.)  */
5845   TYPE_NEEDS_CONSTRUCTING (t)
5846     |= (type_has_user_provided_constructor (t) || TYPE_CONTAINS_VPTR_P (t));
5847   /* [dcl.init.aggr]
5848
5849      An aggregate is an array or a class with no user-provided
5850      constructors ... and no virtual functions.
5851
5852      Again, other conditions for being an aggregate are checked
5853      elsewhere.  */
5854   CLASSTYPE_NON_AGGREGATE (t)
5855     |= (type_has_user_provided_or_explicit_constructor (t)
5856         || TYPE_POLYMORPHIC_P (t));
5857   /* This is the C++98/03 definition of POD; it changed in C++0x, but we
5858      retain the old definition internally for ABI reasons.  */
5859   CLASSTYPE_NON_LAYOUT_POD_P (t)
5860     |= (CLASSTYPE_NON_AGGREGATE (t)
5861         || saved_nontrivial_dtor || saved_complex_asn_ref);
5862   CLASSTYPE_NON_STD_LAYOUT (t) |= TYPE_CONTAINS_VPTR_P (t);
5863   TYPE_HAS_COMPLEX_COPY_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t);
5864   TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t);
5865   TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_CONTAINS_VPTR_P (t);
5866
5867   /* If the only explicitly declared default constructor is user-provided,
5868      set TYPE_HAS_COMPLEX_DFLT.  */
5869   if (!TYPE_HAS_COMPLEX_DFLT (t)
5870       && TYPE_HAS_DEFAULT_CONSTRUCTOR (t)
5871       && !type_has_non_user_provided_default_constructor (t))
5872     TYPE_HAS_COMPLEX_DFLT (t) = true;
5873
5874   /* Warn if a public base of a polymorphic type has an accessible
5875      non-virtual destructor.  It is only now that we know the class is
5876      polymorphic.  Although a polymorphic base will have a already
5877      been diagnosed during its definition, we warn on use too.  */
5878   if (TYPE_POLYMORPHIC_P (t) && warn_nonvdtor)
5879     {
5880       tree binfo = TYPE_BINFO (t);
5881       vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo);
5882       tree base_binfo;
5883       unsigned i;
5884
5885       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
5886         {
5887           tree basetype = TREE_TYPE (base_binfo);
5888
5889           if ((*accesses)[i] == access_public_node
5890               && (TYPE_POLYMORPHIC_P (basetype) || warn_ecpp)
5891               && accessible_nvdtor_p (basetype))
5892             warning (OPT_Wnon_virtual_dtor,
5893                      "base class %q#T has accessible non-virtual destructor",
5894                      basetype);
5895         }
5896     }
5897
5898   /* If the class has no user-declared constructor, but does have
5899      non-static const or reference data members that can never be
5900      initialized, issue a warning.  */
5901   if (warn_uninitialized
5902       /* Classes with user-declared constructors are presumed to
5903          initialize these members.  */
5904       && !TYPE_HAS_USER_CONSTRUCTOR (t)
5905       /* Aggregates can be initialized with brace-enclosed
5906          initializers.  */
5907       && CLASSTYPE_NON_AGGREGATE (t))
5908     {
5909       tree field;
5910
5911       for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
5912         {
5913           tree type;
5914
5915           if (TREE_CODE (field) != FIELD_DECL
5916               || DECL_INITIAL (field) != NULL_TREE)
5917             continue;
5918
5919           type = TREE_TYPE (field);
5920           if (TREE_CODE (type) == REFERENCE_TYPE)
5921             warning_at (DECL_SOURCE_LOCATION (field),
5922                         OPT_Wuninitialized, "non-static reference %q#D "
5923                         "in class without a constructor", field);
5924           else if (CP_TYPE_CONST_P (type)
5925                    && (!CLASS_TYPE_P (type)
5926                        || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
5927             warning_at (DECL_SOURCE_LOCATION (field),
5928                         OPT_Wuninitialized, "non-static const member %q#D "
5929                         "in class without a constructor", field);
5930         }
5931     }
5932
5933   /* Synthesize any needed methods.  */
5934   add_implicitly_declared_members (t, &access_decls,
5935                                    cant_have_const_ctor,
5936                                    no_const_asn_ref);
5937
5938   /* Check defaulted declarations here so we have cant_have_const_ctor
5939      and don't need to worry about clones.  */
5940   for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
5941     if (!DECL_ARTIFICIAL (fn) && DECL_DEFAULTED_IN_CLASS_P (fn))
5942       {
5943         int copy = copy_fn_p (fn);
5944         if (copy > 0)
5945           {
5946             bool imp_const_p
5947               = (DECL_CONSTRUCTOR_P (fn) ? !cant_have_const_ctor
5948                  : !no_const_asn_ref);
5949             bool fn_const_p = (copy == 2);
5950
5951             if (fn_const_p && !imp_const_p)
5952               /* If the function is defaulted outside the class, we just
5953                  give the synthesis error.  */
5954               error ("%q+D declared to take const reference, but implicit "
5955                      "declaration would take non-const", fn);
5956           }
5957         defaulted_late_check (fn);
5958       }
5959
5960   if (LAMBDA_TYPE_P (t))
5961     {
5962       /* "This class type is not an aggregate."  */
5963       CLASSTYPE_NON_AGGREGATE (t) = 1;
5964     }
5965
5966   /* Compute the 'literal type' property before we
5967      do anything with non-static member functions.  */
5968   finalize_literal_type_property (t);
5969
5970   /* Create the in-charge and not-in-charge variants of constructors
5971      and destructors.  */
5972   clone_constructors_and_destructors (t);
5973
5974   /* Process the using-declarations.  */
5975   for (; access_decls; access_decls = TREE_CHAIN (access_decls))
5976     handle_using_decl (TREE_VALUE (access_decls), t);
5977
5978   /* Build and sort the CLASSTYPE_METHOD_VEC.  */
5979   finish_struct_methods (t);
5980
5981   /* Figure out whether or not we will need a cookie when dynamically
5982      allocating an array of this type.  */
5983   TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
5984     = type_requires_array_cookie (t);
5985 }
5986
5987 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
5988    accordingly.  If a new vfield was created (because T doesn't have a
5989    primary base class), then the newly created field is returned.  It
5990    is not added to the TYPE_FIELDS list; it is the caller's
5991    responsibility to do that.  Accumulate declared virtual functions
5992    on VIRTUALS_P.  */
5993
5994 static tree
5995 create_vtable_ptr (tree t, tree* virtuals_p)
5996 {
5997   tree fn;
5998
5999   /* Collect the virtual functions declared in T.  */
6000   for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
6001     if (TREE_CODE (fn) == FUNCTION_DECL
6002         && DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
6003         && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
6004       {
6005         tree new_virtual = make_node (TREE_LIST);
6006
6007         BV_FN (new_virtual) = fn;
6008         BV_DELTA (new_virtual) = integer_zero_node;
6009         BV_VCALL_INDEX (new_virtual) = NULL_TREE;
6010
6011         TREE_CHAIN (new_virtual) = *virtuals_p;
6012         *virtuals_p = new_virtual;
6013       }
6014
6015   /* If we couldn't find an appropriate base class, create a new field
6016      here.  Even if there weren't any new virtual functions, we might need a
6017      new virtual function table if we're supposed to include vptrs in
6018      all classes that need them.  */
6019   if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
6020     {
6021       /* We build this decl with vtbl_ptr_type_node, which is a
6022          `vtable_entry_type*'.  It might seem more precise to use
6023          `vtable_entry_type (*)[N]' where N is the number of virtual
6024          functions.  However, that would require the vtable pointer in
6025          base classes to have a different type than the vtable pointer
6026          in derived classes.  We could make that happen, but that
6027          still wouldn't solve all the problems.  In particular, the
6028          type-based alias analysis code would decide that assignments
6029          to the base class vtable pointer can't alias assignments to
6030          the derived class vtable pointer, since they have different
6031          types.  Thus, in a derived class destructor, where the base
6032          class constructor was inlined, we could generate bad code for
6033          setting up the vtable pointer.
6034
6035          Therefore, we use one type for all vtable pointers.  We still
6036          use a type-correct type; it's just doesn't indicate the array
6037          bounds.  That's better than using `void*' or some such; it's
6038          cleaner, and it let's the alias analysis code know that these
6039          stores cannot alias stores to void*!  */
6040       tree field;
6041
6042       field = build_decl (input_location,
6043                           FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
6044       DECL_VIRTUAL_P (field) = 1;
6045       DECL_ARTIFICIAL (field) = 1;
6046       DECL_FIELD_CONTEXT (field) = t;
6047       DECL_FCONTEXT (field) = t;
6048       if (TYPE_PACKED (t))
6049         DECL_PACKED (field) = 1;
6050
6051       TYPE_VFIELD (t) = field;
6052
6053       /* This class is non-empty.  */
6054       CLASSTYPE_EMPTY_P (t) = 0;
6055
6056       return field;
6057     }
6058
6059   return NULL_TREE;
6060 }
6061
6062 /* Add OFFSET to all base types of BINFO which is a base in the
6063    hierarchy dominated by T.
6064
6065    OFFSET, which is a type offset, is number of bytes.  */
6066
6067 static void
6068 propagate_binfo_offsets (tree binfo, tree offset)
6069 {
6070   int i;
6071   tree primary_binfo;
6072   tree base_binfo;
6073
6074   /* Update BINFO's offset.  */
6075   BINFO_OFFSET (binfo)
6076     = fold_convert (sizetype,
6077                size_binop (PLUS_EXPR,
6078                            fold_convert (ssizetype, BINFO_OFFSET (binfo)),
6079                            offset));
6080
6081   /* Find the primary base class.  */
6082   primary_binfo = get_primary_binfo (binfo);
6083
6084   if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo)
6085     propagate_binfo_offsets (primary_binfo, offset);
6086
6087   /* Scan all of the bases, pushing the BINFO_OFFSET adjust
6088      downwards.  */
6089   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6090     {
6091       /* Don't do the primary base twice.  */
6092       if (base_binfo == primary_binfo)
6093         continue;
6094
6095       if (BINFO_VIRTUAL_P (base_binfo))
6096         continue;
6097
6098       propagate_binfo_offsets (base_binfo, offset);
6099     }
6100 }
6101
6102 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T.  Update
6103    TYPE_ALIGN and TYPE_SIZE for T.  OFFSETS gives the location of
6104    empty subobjects of T.  */
6105
6106 static void
6107 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
6108 {
6109   tree vbase;
6110   tree t = rli->t;
6111   tree *next_field;
6112
6113   if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0)
6114     return;
6115
6116   /* Find the last field.  The artificial fields created for virtual
6117      bases will go after the last extant field to date.  */
6118   next_field = &TYPE_FIELDS (t);
6119   while (*next_field)
6120     next_field = &DECL_CHAIN (*next_field);
6121
6122   /* Go through the virtual bases, allocating space for each virtual
6123      base that is not already a primary base class.  These are
6124      allocated in inheritance graph order.  */
6125   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6126     {
6127       if (!BINFO_VIRTUAL_P (vbase))
6128         continue;
6129
6130       if (!BINFO_PRIMARY_P (vbase))
6131         {
6132           /* This virtual base is not a primary base of any class in the
6133              hierarchy, so we have to add space for it.  */
6134           next_field = build_base_field (rli, vbase,
6135                                          offsets, next_field);
6136         }
6137     }
6138 }
6139
6140 /* Returns the offset of the byte just past the end of the base class
6141    BINFO.  */
6142
6143 static tree
6144 end_of_base (tree binfo)
6145 {
6146   tree size;
6147
6148   if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo)))
6149     size = TYPE_SIZE_UNIT (char_type_node);
6150   else if (is_empty_class (BINFO_TYPE (binfo)))
6151     /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
6152        allocate some space for it. It cannot have virtual bases, so
6153        TYPE_SIZE_UNIT is fine.  */
6154     size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
6155   else
6156     size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
6157
6158   return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
6159 }
6160
6161 /* Returns the offset of the byte just past the end of the base class
6162    with the highest offset in T.  If INCLUDE_VIRTUALS_P is zero, then
6163    only non-virtual bases are included.  */
6164
6165 static tree
6166 end_of_class (tree t, int include_virtuals_p)
6167 {
6168   tree result = size_zero_node;
6169   vec<tree, va_gc> *vbases;
6170   tree binfo;
6171   tree base_binfo;
6172   tree offset;
6173   int i;
6174
6175   for (binfo = TYPE_BINFO (t), i = 0;
6176        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6177     {
6178       if (!include_virtuals_p
6179           && BINFO_VIRTUAL_P (base_binfo)
6180           && (!BINFO_PRIMARY_P (base_binfo)
6181               || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t)))
6182         continue;
6183
6184       offset = end_of_base (base_binfo);
6185       if (tree_int_cst_lt (result, offset))
6186         result = offset;
6187     }
6188
6189   if (include_virtuals_p)
6190     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
6191          vec_safe_iterate (vbases, i, &base_binfo); i++)
6192       {
6193         offset = end_of_base (base_binfo);
6194         if (tree_int_cst_lt (result, offset))
6195           result = offset;
6196       }
6197
6198   return result;
6199 }
6200
6201 /* Warn about bases of T that are inaccessible because they are
6202    ambiguous.  For example:
6203
6204      struct S {};
6205      struct T : public S {};
6206      struct U : public S, public T {};
6207
6208    Here, `(S*) new U' is not allowed because there are two `S'
6209    subobjects of U.  */
6210
6211 static void
6212 warn_about_ambiguous_bases (tree t)
6213 {
6214   int i;
6215   vec<tree, va_gc> *vbases;
6216   tree basetype;
6217   tree binfo;
6218   tree base_binfo;
6219
6220   /* If there are no repeated bases, nothing can be ambiguous.  */
6221   if (!CLASSTYPE_REPEATED_BASE_P (t))
6222     return;
6223
6224   /* Check direct bases.  */
6225   for (binfo = TYPE_BINFO (t), i = 0;
6226        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6227     {
6228       basetype = BINFO_TYPE (base_binfo);
6229
6230       if (!uniquely_derived_from_p (basetype, t))
6231         warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
6232                  basetype, t);
6233     }
6234
6235   /* Check for ambiguous virtual bases.  */
6236   if (extra_warnings)
6237     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
6238          vec_safe_iterate (vbases, i, &binfo); i++)
6239       {
6240         basetype = BINFO_TYPE (binfo);
6241
6242         if (!uniquely_derived_from_p (basetype, t))
6243           warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due "
6244                    "to ambiguity", basetype, t);
6245       }
6246 }
6247
6248 /* Compare two INTEGER_CSTs K1 and K2.  */
6249
6250 static int
6251 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
6252 {
6253   return tree_int_cst_compare ((tree) k1, (tree) k2);
6254 }
6255
6256 /* Increase the size indicated in RLI to account for empty classes
6257    that are "off the end" of the class.  */
6258
6259 static void
6260 include_empty_classes (record_layout_info rli)
6261 {
6262   tree eoc;
6263   tree rli_size;
6264
6265   /* It might be the case that we grew the class to allocate a
6266      zero-sized base class.  That won't be reflected in RLI, yet,
6267      because we are willing to overlay multiple bases at the same
6268      offset.  However, now we need to make sure that RLI is big enough
6269      to reflect the entire class.  */
6270   eoc = end_of_class (rli->t,
6271                       CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
6272   rli_size = rli_size_unit_so_far (rli);
6273   if (TREE_CODE (rli_size) == INTEGER_CST
6274       && tree_int_cst_lt (rli_size, eoc))
6275     {
6276       /* The size should have been rounded to a whole byte.  */
6277       gcc_assert (tree_int_cst_equal
6278                   (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT)));
6279       rli->bitpos
6280         = size_binop (PLUS_EXPR,
6281                       rli->bitpos,
6282                       size_binop (MULT_EXPR,
6283                                   fold_convert (bitsizetype,
6284                                            size_binop (MINUS_EXPR,
6285                                                        eoc, rli_size)),
6286                                   bitsize_int (BITS_PER_UNIT)));
6287       normalize_rli (rli);
6288     }
6289 }
6290
6291 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T.  Calculate
6292    BINFO_OFFSETs for all of the base-classes.  Position the vtable
6293    pointer.  Accumulate declared virtual functions on VIRTUALS_P.  */
6294
6295 static void
6296 layout_class_type (tree t, tree *virtuals_p)
6297 {
6298   tree non_static_data_members;
6299   tree field;
6300   tree vptr;
6301   record_layout_info rli;
6302   /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
6303      types that appear at that offset.  */
6304   splay_tree empty_base_offsets;
6305   /* True if the last field laid out was a bit-field.  */
6306   bool last_field_was_bitfield = false;
6307   /* The location at which the next field should be inserted.  */
6308   tree *next_field;
6309   /* T, as a base class.  */
6310   tree base_t;
6311
6312   /* Keep track of the first non-static data member.  */
6313   non_static_data_members = TYPE_FIELDS (t);
6314
6315   /* Start laying out the record.  */
6316   rli = start_record_layout (t);
6317
6318   /* Mark all the primary bases in the hierarchy.  */
6319   determine_primary_bases (t);
6320
6321   /* Create a pointer to our virtual function table.  */
6322   vptr = create_vtable_ptr (t, virtuals_p);
6323
6324   /* The vptr is always the first thing in the class.  */
6325   if (vptr)
6326     {
6327       DECL_CHAIN (vptr) = TYPE_FIELDS (t);
6328       TYPE_FIELDS (t) = vptr;
6329       next_field = &DECL_CHAIN (vptr);
6330       place_field (rli, vptr);
6331     }
6332   else
6333     next_field = &TYPE_FIELDS (t);
6334
6335   /* Build FIELD_DECLs for all of the non-virtual base-types.  */
6336   empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
6337                                        NULL, NULL);
6338   build_base_fields (rli, empty_base_offsets, next_field);
6339
6340   /* Layout the non-static data members.  */
6341   for (field = non_static_data_members; field; field = DECL_CHAIN (field))
6342     {
6343       tree type;
6344       tree padding;
6345
6346       /* We still pass things that aren't non-static data members to
6347          the back end, in case it wants to do something with them.  */
6348       if (TREE_CODE (field) != FIELD_DECL)
6349         {
6350           place_field (rli, field);
6351           /* If the static data member has incomplete type, keep track
6352              of it so that it can be completed later.  (The handling
6353              of pending statics in finish_record_layout is
6354              insufficient; consider:
6355
6356                struct S1;
6357                struct S2 { static S1 s1; };
6358
6359              At this point, finish_record_layout will be called, but
6360              S1 is still incomplete.)  */
6361           if (VAR_P (field))
6362             {
6363               maybe_register_incomplete_var (field);
6364               /* The visibility of static data members is determined
6365                  at their point of declaration, not their point of
6366                  definition.  */
6367               determine_visibility (field);
6368             }
6369           continue;
6370         }
6371
6372       type = TREE_TYPE (field);
6373       if (type == error_mark_node)
6374         continue;
6375
6376       padding = NULL_TREE;
6377
6378       /* If this field is a bit-field whose width is greater than its
6379          type, then there are some special rules for allocating
6380          it.  */
6381       if (DECL_C_BIT_FIELD (field)
6382           && tree_int_cst_lt (TYPE_SIZE (type), DECL_SIZE (field)))
6383         {
6384           unsigned int itk;
6385           tree integer_type;
6386           bool was_unnamed_p = false;
6387           /* We must allocate the bits as if suitably aligned for the
6388              longest integer type that fits in this many bits.  type
6389              of the field.  Then, we are supposed to use the left over
6390              bits as additional padding.  */
6391           for (itk = itk_char; itk != itk_none; ++itk)
6392             if (integer_types[itk] != NULL_TREE
6393                 && (tree_int_cst_lt (size_int (MAX_FIXED_MODE_SIZE),
6394                                      TYPE_SIZE (integer_types[itk]))
6395                     || tree_int_cst_lt (DECL_SIZE (field),
6396                                         TYPE_SIZE (integer_types[itk]))))
6397               break;
6398
6399           /* ITK now indicates a type that is too large for the
6400              field.  We have to back up by one to find the largest
6401              type that fits.  */
6402           do
6403           {
6404             --itk;
6405             integer_type = integer_types[itk];
6406           } while (itk > 0 && integer_type == NULL_TREE);
6407
6408           /* Figure out how much additional padding is required.  */
6409           if (tree_int_cst_lt (TYPE_SIZE (integer_type), DECL_SIZE (field)))
6410             {
6411               if (TREE_CODE (t) == UNION_TYPE)
6412                 /* In a union, the padding field must have the full width
6413                    of the bit-field; all fields start at offset zero.  */
6414                 padding = DECL_SIZE (field);
6415               else
6416                 padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
6417                                       TYPE_SIZE (integer_type));
6418             }
6419
6420           /* An unnamed bitfield does not normally affect the
6421              alignment of the containing class on a target where
6422              PCC_BITFIELD_TYPE_MATTERS.  But, the C++ ABI does not
6423              make any exceptions for unnamed bitfields when the
6424              bitfields are longer than their types.  Therefore, we
6425              temporarily give the field a name.  */
6426           if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
6427             {
6428               was_unnamed_p = true;
6429               DECL_NAME (field) = make_anon_name ();
6430             }
6431
6432           DECL_SIZE (field) = TYPE_SIZE (integer_type);
6433           SET_DECL_ALIGN (field, TYPE_ALIGN (integer_type));
6434           DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
6435           layout_nonempty_base_or_field (rli, field, NULL_TREE,
6436                                          empty_base_offsets);
6437           if (was_unnamed_p)
6438             DECL_NAME (field) = NULL_TREE;
6439           /* Now that layout has been performed, set the size of the
6440              field to the size of its declared type; the rest of the
6441              field is effectively invisible.  */
6442           DECL_SIZE (field) = TYPE_SIZE (type);
6443           /* We must also reset the DECL_MODE of the field.  */
6444           DECL_MODE (field) = TYPE_MODE (type);
6445         }
6446       else
6447         layout_nonempty_base_or_field (rli, field, NULL_TREE,
6448                                        empty_base_offsets);
6449
6450       /* Remember the location of any empty classes in FIELD.  */
6451       record_subobject_offsets (TREE_TYPE (field),
6452                                 byte_position(field),
6453                                 empty_base_offsets,
6454                                 /*is_data_member=*/true);
6455
6456       /* If a bit-field does not immediately follow another bit-field,
6457          and yet it starts in the middle of a byte, we have failed to
6458          comply with the ABI.  */
6459       if (warn_abi
6460           && DECL_C_BIT_FIELD (field)
6461           /* The TREE_NO_WARNING flag gets set by Objective-C when
6462              laying out an Objective-C class.  The ObjC ABI differs
6463              from the C++ ABI, and so we do not want a warning
6464              here.  */
6465           && !TREE_NO_WARNING (field)
6466           && !last_field_was_bitfield
6467           && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
6468                                          DECL_FIELD_BIT_OFFSET (field),
6469                                          bitsize_unit_node)))
6470         warning_at (DECL_SOURCE_LOCATION (field), OPT_Wabi,
6471                     "offset of %qD is not ABI-compliant and may "
6472                     "change in a future version of GCC", field);
6473
6474       /* The middle end uses the type of expressions to determine the
6475          possible range of expression values.  In order to optimize
6476          "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
6477          must be made aware of the width of "i", via its type.
6478
6479          Because C++ does not have integer types of arbitrary width,
6480          we must (for the purposes of the front end) convert from the
6481          type assigned here to the declared type of the bitfield
6482          whenever a bitfield expression is used as an rvalue.
6483          Similarly, when assigning a value to a bitfield, the value
6484          must be converted to the type given the bitfield here.  */
6485       if (DECL_C_BIT_FIELD (field))
6486         {
6487           unsigned HOST_WIDE_INT width;
6488           tree ftype = TREE_TYPE (field);
6489           width = tree_to_uhwi (DECL_SIZE (field));
6490           if (width != TYPE_PRECISION (ftype))
6491             {
6492               TREE_TYPE (field)
6493                 = c_build_bitfield_integer_type (width,
6494                                                  TYPE_UNSIGNED (ftype));
6495               TREE_TYPE (field)
6496                 = cp_build_qualified_type (TREE_TYPE (field),
6497                                            cp_type_quals (ftype));
6498             }
6499         }
6500
6501       /* If we needed additional padding after this field, add it
6502          now.  */
6503       if (padding)
6504         {
6505           tree padding_field;
6506
6507           padding_field = build_decl (input_location,
6508                                       FIELD_DECL,
6509                                       NULL_TREE,
6510                                       char_type_node);
6511           DECL_BIT_FIELD (padding_field) = 1;
6512           DECL_SIZE (padding_field) = padding;
6513           DECL_CONTEXT (padding_field) = t;
6514           DECL_ARTIFICIAL (padding_field) = 1;
6515           DECL_IGNORED_P (padding_field) = 1;
6516           layout_nonempty_base_or_field (rli, padding_field,
6517                                          NULL_TREE,
6518                                          empty_base_offsets);
6519         }
6520
6521       last_field_was_bitfield = DECL_C_BIT_FIELD (field);
6522     }
6523
6524   if (!integer_zerop (rli->bitpos))
6525     {
6526       /* Make sure that we are on a byte boundary so that the size of
6527          the class without virtual bases will always be a round number
6528          of bytes.  */
6529       rli->bitpos = round_up_loc (input_location, rli->bitpos, BITS_PER_UNIT);
6530       normalize_rli (rli);
6531     }
6532
6533   /* Delete all zero-width bit-fields from the list of fields.  Now
6534      that the type is laid out they are no longer important.  */
6535   remove_zero_width_bit_fields (t);
6536
6537   /* Create the version of T used for virtual bases.  We do not use
6538      make_class_type for this version; this is an artificial type.  For
6539      a POD type, we just reuse T.  */
6540   if (CLASSTYPE_NON_LAYOUT_POD_P (t) || CLASSTYPE_EMPTY_P (t))
6541     {
6542       base_t = make_node (TREE_CODE (t));
6543
6544       /* Set the size and alignment for the new type.  */
6545       tree eoc;
6546
6547       /* If the ABI version is not at least two, and the last
6548          field was a bit-field, RLI may not be on a byte
6549          boundary.  In particular, rli_size_unit_so_far might
6550          indicate the last complete byte, while rli_size_so_far
6551          indicates the total number of bits used.  Therefore,
6552          rli_size_so_far, rather than rli_size_unit_so_far, is
6553          used to compute TYPE_SIZE_UNIT.  */
6554       eoc = end_of_class (t, /*include_virtuals_p=*/0);
6555       TYPE_SIZE_UNIT (base_t)
6556         = size_binop (MAX_EXPR,
6557                       fold_convert (sizetype,
6558                                size_binop (CEIL_DIV_EXPR,
6559                                            rli_size_so_far (rli),
6560                                            bitsize_int (BITS_PER_UNIT))),
6561                       eoc);
6562       TYPE_SIZE (base_t)
6563         = size_binop (MAX_EXPR,
6564                       rli_size_so_far (rli),
6565                       size_binop (MULT_EXPR,
6566                                   fold_convert (bitsizetype, eoc),
6567                                   bitsize_int (BITS_PER_UNIT)));
6568       SET_TYPE_ALIGN (base_t, rli->record_align);
6569       TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
6570
6571       /* Copy the fields from T.  */
6572       next_field = &TYPE_FIELDS (base_t);
6573       for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
6574         if (TREE_CODE (field) == FIELD_DECL)
6575           {
6576             *next_field = copy_node (field);
6577             DECL_CONTEXT (*next_field) = base_t;
6578             next_field = &DECL_CHAIN (*next_field);
6579           }
6580       *next_field = NULL_TREE;
6581
6582       /* Record the base version of the type.  */
6583       CLASSTYPE_AS_BASE (t) = base_t;
6584       TYPE_CONTEXT (base_t) = t;
6585     }
6586   else
6587     CLASSTYPE_AS_BASE (t) = t;
6588
6589   /* Every empty class contains an empty class.  */
6590   if (CLASSTYPE_EMPTY_P (t))
6591     CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
6592
6593   /* Set the TYPE_DECL for this type to contain the right
6594      value for DECL_OFFSET, so that we can use it as part
6595      of a COMPONENT_REF for multiple inheritance.  */
6596   layout_decl (TYPE_MAIN_DECL (t), 0);
6597
6598   /* Now fix up any virtual base class types that we left lying
6599      around.  We must get these done before we try to lay out the
6600      virtual function table.  As a side-effect, this will remove the
6601      base subobject fields.  */
6602   layout_virtual_bases (rli, empty_base_offsets);
6603
6604   /* Make sure that empty classes are reflected in RLI at this
6605      point.  */
6606   include_empty_classes(rli);
6607
6608   /* Make sure not to create any structures with zero size.  */
6609   if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
6610     place_field (rli,
6611                  build_decl (input_location,
6612                              FIELD_DECL, NULL_TREE, char_type_node));
6613
6614   /* If this is a non-POD, declaring it packed makes a difference to how it
6615      can be used as a field; don't let finalize_record_size undo it.  */
6616   if (TYPE_PACKED (t) && !layout_pod_type_p (t))
6617     rli->packed_maybe_necessary = true;
6618
6619   /* Let the back end lay out the type.  */
6620   finish_record_layout (rli, /*free_p=*/true);
6621
6622   if (TYPE_SIZE_UNIT (t)
6623       && TREE_CODE (TYPE_SIZE_UNIT (t)) == INTEGER_CST
6624       && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t))
6625       && !valid_constant_size_p (TYPE_SIZE_UNIT (t)))
6626     error ("size of type %qT is too large (%qE bytes)", t, TYPE_SIZE_UNIT (t));
6627
6628   /* Warn about bases that can't be talked about due to ambiguity.  */
6629   warn_about_ambiguous_bases (t);
6630
6631   /* Now that we're done with layout, give the base fields the real types.  */
6632   for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
6633     if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
6634       TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
6635
6636   /* Clean up.  */
6637   splay_tree_delete (empty_base_offsets);
6638
6639   if (CLASSTYPE_EMPTY_P (t)
6640       && tree_int_cst_lt (sizeof_biggest_empty_class,
6641                           TYPE_SIZE_UNIT (t)))
6642     sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
6643 }
6644
6645 /* Determine the "key method" for the class type indicated by TYPE,
6646    and set CLASSTYPE_KEY_METHOD accordingly.  */
6647
6648 void
6649 determine_key_method (tree type)
6650 {
6651   tree method;
6652
6653   if (TYPE_FOR_JAVA (type)
6654       || processing_template_decl
6655       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
6656       || CLASSTYPE_INTERFACE_KNOWN (type))
6657     return;
6658
6659   /* The key method is the first non-pure virtual function that is not
6660      inline at the point of class definition.  On some targets the
6661      key function may not be inline; those targets should not call
6662      this function until the end of the translation unit.  */
6663   for (method = TYPE_METHODS (type); method != NULL_TREE;
6664        method = DECL_CHAIN (method))
6665     if (TREE_CODE (method) == FUNCTION_DECL
6666         && DECL_VINDEX (method) != NULL_TREE
6667         && ! DECL_DECLARED_INLINE_P (method)
6668         && ! DECL_PURE_VIRTUAL_P (method))
6669       {
6670         CLASSTYPE_KEY_METHOD (type) = method;
6671         break;
6672       }
6673
6674   return;
6675 }
6676
6677
6678 /* Allocate and return an instance of struct sorted_fields_type with
6679    N fields.  */
6680
6681 static struct sorted_fields_type *
6682 sorted_fields_type_new (int n)
6683 {
6684   struct sorted_fields_type *sft;
6685   sft = (sorted_fields_type *) ggc_internal_alloc (sizeof (sorted_fields_type)
6686                                       + n * sizeof (tree));
6687   sft->len = n;
6688
6689   return sft;
6690 }
6691
6692 /* Helper of find_flexarrays.  Return true when FLD refers to a non-static
6693    class data member of non-zero size, otherwise false.  */
6694
6695 static inline bool
6696 field_nonempty_p (const_tree fld)
6697 {
6698   if (TREE_CODE (fld) == ERROR_MARK)
6699     return false;
6700
6701   tree type = TREE_TYPE (fld);
6702   if (TREE_CODE (fld) == FIELD_DECL
6703       && TREE_CODE (type) != ERROR_MARK
6704       && (DECL_NAME (fld) || RECORD_OR_UNION_TYPE_P (type)))
6705     {
6706       return TYPE_SIZE (type)
6707         && (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
6708             || !tree_int_cst_equal (size_zero_node, TYPE_SIZE (type)));
6709     }
6710
6711   return false;
6712 }
6713
6714 /* Used by find_flexarrays and related.  */
6715 struct flexmems_t {
6716   /* The first flexible array member or non-zero array member found
6717      in order of layout.  */
6718   tree array;
6719   /* First non-static non-empty data member in the class or its bases.  */
6720   tree first;
6721   /* First non-static non-empty data member following either the flexible
6722      array member, if found, or the zero-length array member.  */
6723   tree after;
6724 };
6725
6726 /* Find either the first flexible array member or the first zero-length
6727    array, in that order or preference, among members of class T (but not
6728    its base classes), and set members of FMEM accordingly.  */
6729
6730 static void
6731 find_flexarrays (tree t, flexmems_t *fmem)
6732 {
6733   for (tree fld = TYPE_FIELDS (t), next; fld; fld = next)
6734     {
6735       /* Find the next non-static data member if it exists.  */
6736       for (next = fld;
6737            (next = DECL_CHAIN (next))
6738              && TREE_CODE (next) != FIELD_DECL; );
6739
6740       tree fldtype = TREE_TYPE (fld);
6741       if (TREE_CODE (fld) != TYPE_DECL
6742           && RECORD_OR_UNION_TYPE_P (fldtype)
6743           && TYPE_UNNAMED_P (fldtype))
6744         {
6745           /* Members of anonymous structs and unions are treated as if
6746              they were members of the containing class.  Descend into
6747              the anonymous struct or union and find a flexible array
6748              member or zero-length array among its fields.  */
6749           find_flexarrays (fldtype, fmem);
6750           continue;
6751         }
6752
6753       /* Skip anything that's not a (non-static) data member.  */
6754       if (TREE_CODE (fld) != FIELD_DECL)
6755         continue;
6756
6757       /* Skip virtual table pointers.  */
6758       if (DECL_ARTIFICIAL (fld))
6759         continue;
6760
6761       if (field_nonempty_p (fld))
6762         {
6763           /* Remember the first non-static data member.  */
6764           if (!fmem->first)
6765             fmem->first = fld;
6766
6767           /* Remember the first non-static data member after the flexible
6768              array member, if one has been found, or the zero-length array
6769              if it has been found.  */
6770           if (!fmem->after && fmem->array)
6771             fmem->after = fld;
6772         }
6773
6774       /* Skip non-arrays.  */
6775       if (TREE_CODE (fldtype) != ARRAY_TYPE)
6776         continue;
6777
6778       /* Determine the upper bound of the array if it has one.  */
6779       if (TYPE_DOMAIN (fldtype))
6780         {
6781           if (fmem->array)
6782             {
6783               /* Make a record of the zero-length array if either one
6784                  such field or a flexible array member has been seen to
6785                  handle the pathological and unlikely case of multiple
6786                  such members.  */
6787               if (!fmem->after)
6788                 fmem->after = fld;
6789             }
6790           else if (integer_all_onesp (TYPE_MAX_VALUE (TYPE_DOMAIN (fldtype))))
6791             /* Remember the first zero-length array unless a flexible array
6792                member has already been seen.  */
6793             fmem->array = fld;
6794         }
6795       else
6796         {
6797           /* Flexible array members have no upper bound.  */
6798           if (fmem->array)
6799             {
6800               /* Replace the zero-length array if it's been stored and
6801                  reset the after pointer.  */
6802               if (TYPE_DOMAIN (TREE_TYPE (fmem->array)))
6803                 {
6804                   fmem->array = fld;
6805                   fmem->after = NULL_TREE;
6806                 }
6807             }
6808           else
6809             fmem->array = fld;
6810         }
6811     }
6812 }
6813
6814 /* Issue diagnostics for invalid flexible array members or zero-length
6815    arrays that are not the last elements of the containing class or its
6816    base classes or that are its sole members.  */
6817
6818 static void
6819 diagnose_flexarrays (tree t, const flexmems_t *fmem)
6820 {
6821   /* Members of anonymous structs and unions are considered to be members
6822      of the containing struct or union.  */
6823   if (TYPE_UNNAMED_P (t) || !fmem->array)
6824     return;
6825
6826   const char *msg = 0;
6827
6828   if (TYPE_DOMAIN (TREE_TYPE (fmem->array)))
6829     {
6830       if (fmem->after)
6831         msg = G_("zero-size array member %qD not at end of %q#T");
6832       else if (!fmem->first)
6833         msg = G_("zero-size array member %qD in an otherwise empty %q#T");
6834
6835       if (msg && pedwarn (DECL_SOURCE_LOCATION (fmem->array),
6836                           OPT_Wpedantic, msg, fmem->array, t))
6837
6838         inform (location_of (t), "in the definition of %q#T", t);
6839     }
6840   else
6841     {
6842       if (fmem->after)
6843         msg = G_("flexible array member %qD not at end of %q#T");
6844       else if (!fmem->first)
6845         msg = G_("flexible array member %qD in an otherwise empty %q#T");
6846
6847       if (msg)
6848         {
6849           error_at (DECL_SOURCE_LOCATION (fmem->array), msg,
6850                     fmem->array, t);
6851
6852           /* In the unlikely event that the member following the flexible
6853              array member is declared in a different class, point to it.
6854              Otherwise it should be obvious.  */
6855           if (fmem->after
6856               && (DECL_CONTEXT (fmem->after) != DECL_CONTEXT (fmem->array)))
6857               inform (DECL_SOURCE_LOCATION (fmem->after),
6858                       "next member %q#D declared here",
6859                       fmem->after);
6860
6861           inform (location_of (t), "in the definition of %q#T", t);
6862         }
6863     }
6864 }
6865
6866
6867 /* Recursively check to make sure that any flexible array or zero-length
6868    array members of class T or its bases are valid (i.e., not the sole
6869    non-static data member of T and, if one exists, that it is the last
6870    non-static data member of T and its base classes.  FMEM is expected
6871    to be initially null and is used internally by recursive calls to
6872    the function.  Issue the appropriate diagnostics for the array member
6873    that fails the checks.  */
6874
6875 static void
6876 check_flexarrays (tree t, flexmems_t *fmem /* = NULL */)
6877 {
6878   /* Initialize the result of a search for flexible array and zero-length
6879      array members.  Avoid doing any work if the most interesting FMEM data
6880      have already been populated.  */
6881   flexmems_t flexmems = flexmems_t ();
6882   if (!fmem)
6883     fmem = &flexmems;
6884   else if (fmem->array && fmem->first && fmem->after)
6885     return;
6886
6887   /* Recursively check the primary base class first.  */
6888   if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
6889     {
6890       tree basetype = BINFO_TYPE (CLASSTYPE_PRIMARY_BINFO (t));
6891       check_flexarrays (basetype, fmem);
6892     }
6893
6894   /* Recursively check the base classes.  */
6895   int nbases = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
6896   for (int i = 0; i < nbases; ++i)
6897     {
6898       tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
6899
6900       /* The primary base class was already checked above.  */
6901       if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
6902         continue;
6903
6904       /* Virtual base classes are at the end.  */
6905       if (BINFO_VIRTUAL_P (base_binfo))
6906         continue;
6907
6908       /* Check the base class.  */
6909       check_flexarrays (BINFO_TYPE (base_binfo), fmem);
6910     }
6911
6912   if (fmem == &flexmems)
6913     {
6914       /* Check virtual base classes only once per derived class.
6915          I.e., this check is not performed recursively for base
6916          classes.  */
6917       int i;
6918       tree base_binfo;
6919       vec<tree, va_gc> *vbases;
6920       for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
6921            vec_safe_iterate (vbases, i, &base_binfo); i++)
6922         {
6923           /* Check the virtual base class.  */
6924           tree basetype = TREE_TYPE (base_binfo);
6925
6926           check_flexarrays (basetype, fmem);
6927         }
6928     }
6929
6930   /* Search the members of the current (derived) class.  */
6931   find_flexarrays (t, fmem);
6932
6933   if (fmem == &flexmems)
6934     {
6935       /* Issue diagnostics for invalid flexible and zero-length array members
6936          found in base classes or among the members of the current class.  */
6937       diagnose_flexarrays (t, fmem);
6938     }
6939 }
6940
6941 /* Perform processing required when the definition of T (a class type)
6942    is complete.  Diagnose invalid definitions of flexible array members
6943    and zero-size arrays.  */
6944
6945 void
6946 finish_struct_1 (tree t)
6947 {
6948   tree x;
6949   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
6950   tree virtuals = NULL_TREE;
6951
6952   if (COMPLETE_TYPE_P (t))
6953     {
6954       gcc_assert (MAYBE_CLASS_TYPE_P (t));
6955       error ("redefinition of %q#T", t);
6956       popclass ();
6957       return;
6958     }
6959
6960   /* If this type was previously laid out as a forward reference,
6961      make sure we lay it out again.  */
6962   TYPE_SIZE (t) = NULL_TREE;
6963   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
6964
6965   /* Make assumptions about the class; we'll reset the flags if
6966      necessary.  */
6967   CLASSTYPE_EMPTY_P (t) = 1;
6968   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
6969   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
6970   CLASSTYPE_LITERAL_P (t) = true;
6971
6972   /* Do end-of-class semantic processing: checking the validity of the
6973      bases and members and add implicitly generated methods.  */
6974   check_bases_and_members (t);
6975
6976   /* Find the key method.  */
6977   if (TYPE_CONTAINS_VPTR_P (t))
6978     {
6979       /* The Itanium C++ ABI permits the key method to be chosen when
6980          the class is defined -- even though the key method so
6981          selected may later turn out to be an inline function.  On
6982          some systems (such as ARM Symbian OS) the key method cannot
6983          be determined until the end of the translation unit.  On such
6984          systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
6985          will cause the class to be added to KEYED_CLASSES.  Then, in
6986          finish_file we will determine the key method.  */
6987       if (targetm.cxx.key_method_may_be_inline ())
6988         determine_key_method (t);
6989
6990       /* If a polymorphic class has no key method, we may emit the vtable
6991          in every translation unit where the class definition appears.  If
6992          we're devirtualizing, we can look into the vtable even if we
6993          aren't emitting it.  */
6994       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
6995         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
6996     }
6997
6998   /* Layout the class itself.  */
6999   layout_class_type (t, &virtuals);
7000   if (CLASSTYPE_AS_BASE (t) != t)
7001     /* We use the base type for trivial assignments, and hence it
7002        needs a mode.  */
7003     compute_record_mode (CLASSTYPE_AS_BASE (t));
7004
7005   /* With the layout complete, check for flexible array members and
7006      zero-length arrays that might overlap other members in the final
7007      layout.  */
7008   check_flexarrays (t);
7009
7010   virtuals = modify_all_vtables (t, nreverse (virtuals));
7011
7012   /* If necessary, create the primary vtable for this class.  */
7013   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
7014     {
7015       /* We must enter these virtuals into the table.  */
7016       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
7017         build_primary_vtable (NULL_TREE, t);
7018       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
7019         /* Here we know enough to change the type of our virtual
7020            function table, but we will wait until later this function.  */
7021         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
7022
7023       /* If we're warning about ABI tags, check the types of the new
7024          virtual functions.  */
7025       if (warn_abi_tag)
7026         for (tree v = virtuals; v; v = TREE_CHAIN (v))
7027           check_abi_tags (t, TREE_VALUE (v));
7028     }
7029
7030   if (TYPE_CONTAINS_VPTR_P (t))
7031     {
7032       int vindex;
7033       tree fn;
7034
7035       if (BINFO_VTABLE (TYPE_BINFO (t)))
7036         gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
7037       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
7038         gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
7039
7040       /* Add entries for virtual functions introduced by this class.  */
7041       BINFO_VIRTUALS (TYPE_BINFO (t))
7042         = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
7043
7044       /* Set DECL_VINDEX for all functions declared in this class.  */
7045       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
7046            fn;
7047            fn = TREE_CHAIN (fn),
7048              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
7049                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
7050         {
7051           tree fndecl = BV_FN (fn);
7052
7053           if (DECL_THUNK_P (fndecl))
7054             /* A thunk. We should never be calling this entry directly
7055                from this vtable -- we'd use the entry for the non
7056                thunk base function.  */
7057             DECL_VINDEX (fndecl) = NULL_TREE;
7058           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
7059             DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
7060         }
7061     }
7062
7063   finish_struct_bits (t);
7064   set_method_tm_attributes (t);
7065   if (flag_openmp || flag_openmp_simd)
7066     finish_omp_declare_simd_methods (t);
7067
7068   /* Complete the rtl for any static member objects of the type we're
7069      working on.  */
7070   for (x = TYPE_FIELDS (t); x; x = DECL_CHAIN (x))
7071     if (VAR_P (x) && TREE_STATIC (x)
7072         && TREE_TYPE (x) != error_mark_node
7073         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
7074       DECL_MODE (x) = TYPE_MODE (t);
7075
7076   /* Done with FIELDS...now decide whether to sort these for
7077      faster lookups later.
7078
7079      We use a small number because most searches fail (succeeding
7080      ultimately as the search bores through the inheritance
7081      hierarchy), and we want this failure to occur quickly.  */
7082
7083   insert_into_classtype_sorted_fields (TYPE_FIELDS (t), t, 8);
7084
7085   /* Complain if one of the field types requires lower visibility.  */
7086   constrain_class_visibility (t);
7087
7088   /* Make the rtl for any new vtables we have created, and unmark
7089      the base types we marked.  */
7090   finish_vtbls (t);
7091
7092   /* Build the VTT for T.  */
7093   build_vtt (t);
7094
7095   /* This warning does not make sense for Java classes, since they
7096      cannot have destructors.  */
7097   if (!TYPE_FOR_JAVA (t) && warn_nonvdtor
7098       && TYPE_POLYMORPHIC_P (t) && accessible_nvdtor_p (t)
7099       && !CLASSTYPE_FINAL (t))
7100     warning (OPT_Wnon_virtual_dtor,
7101              "%q#T has virtual functions and accessible"
7102              " non-virtual destructor", t);
7103
7104   complete_vars (t);
7105
7106   if (warn_overloaded_virtual)
7107     warn_hidden (t);
7108
7109   /* Class layout, assignment of virtual table slots, etc., is now
7110      complete.  Give the back end a chance to tweak the visibility of
7111      the class or perform any other required target modifications.  */
7112   targetm.cxx.adjust_class_at_definition (t);
7113
7114   maybe_suppress_debug_info (t);
7115
7116   if (flag_vtable_verify)
7117     vtv_save_class_info (t);
7118
7119   dump_class_hierarchy (t);
7120
7121   /* Finish debugging output for this type.  */
7122   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
7123
7124   if (TYPE_TRANSPARENT_AGGR (t))
7125     {
7126       tree field = first_field (t);
7127       if (field == NULL_TREE || error_operand_p (field))
7128         {
7129           error ("type transparent %q#T does not have any fields", t);
7130           TYPE_TRANSPARENT_AGGR (t) = 0;
7131         }
7132       else if (DECL_ARTIFICIAL (field))
7133         {
7134           if (DECL_FIELD_IS_BASE (field))
7135             error ("type transparent class %qT has base classes", t);
7136           else
7137             {
7138               gcc_checking_assert (DECL_VIRTUAL_P (field));
7139               error ("type transparent class %qT has virtual functions", t);
7140             }
7141           TYPE_TRANSPARENT_AGGR (t) = 0;
7142         }
7143       else if (TYPE_MODE (t) != DECL_MODE (field))
7144         {
7145           error ("type transparent %q#T cannot be made transparent because "
7146                  "the type of the first field has a different ABI from the "
7147                  "class overall", t);
7148           TYPE_TRANSPARENT_AGGR (t) = 0;
7149         }
7150     }
7151 }
7152
7153 /* Insert FIELDS into T for the sorted case if the FIELDS count is
7154    equal to THRESHOLD or greater than THRESHOLD.  */
7155
7156 static void
7157 insert_into_classtype_sorted_fields (tree fields, tree t, int threshold)
7158 {
7159   int n_fields = count_fields (fields);
7160   if (n_fields >= threshold)
7161     {
7162       struct sorted_fields_type *field_vec = sorted_fields_type_new (n_fields);
7163       add_fields_to_record_type (fields, field_vec, 0);
7164       qsort (field_vec->elts, n_fields, sizeof (tree), field_decl_cmp);
7165       CLASSTYPE_SORTED_FIELDS (t) = field_vec;
7166     }
7167 }
7168
7169 /* Insert lately defined enum ENUMTYPE into T for the sorted case.  */
7170
7171 void
7172 insert_late_enum_def_into_classtype_sorted_fields (tree enumtype, tree t)
7173 {
7174   struct sorted_fields_type *sorted_fields = CLASSTYPE_SORTED_FIELDS (t);
7175   if (sorted_fields)
7176     {
7177       int i;
7178       int n_fields
7179         = list_length (TYPE_VALUES (enumtype)) + sorted_fields->len;
7180       struct sorted_fields_type *field_vec = sorted_fields_type_new (n_fields);
7181
7182       for (i = 0; i < sorted_fields->len; ++i)
7183         field_vec->elts[i] = sorted_fields->elts[i];
7184
7185       add_enum_fields_to_record_type (enumtype, field_vec,
7186                                       sorted_fields->len);
7187       qsort (field_vec->elts, n_fields, sizeof (tree), field_decl_cmp);
7188       CLASSTYPE_SORTED_FIELDS (t) = field_vec;
7189     }
7190 }
7191
7192 /* When T was built up, the member declarations were added in reverse
7193    order.  Rearrange them to declaration order.  */
7194
7195 void
7196 unreverse_member_declarations (tree t)
7197 {
7198   tree next;
7199   tree prev;
7200   tree x;
7201
7202   /* The following lists are all in reverse order.  Put them in
7203      declaration order now.  */
7204   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
7205   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
7206
7207   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
7208      reverse order, so we can't just use nreverse.  */
7209   prev = NULL_TREE;
7210   for (x = TYPE_FIELDS (t);
7211        x && TREE_CODE (x) != TYPE_DECL;
7212        x = next)
7213     {
7214       next = DECL_CHAIN (x);
7215       DECL_CHAIN (x) = prev;
7216       prev = x;
7217     }
7218   if (prev)
7219     {
7220       DECL_CHAIN (TYPE_FIELDS (t)) = x;
7221       if (prev)
7222         TYPE_FIELDS (t) = prev;
7223     }
7224 }
7225
7226 tree
7227 finish_struct (tree t, tree attributes)
7228 {
7229   location_t saved_loc = input_location;
7230
7231   /* Now that we've got all the field declarations, reverse everything
7232      as necessary.  */
7233   unreverse_member_declarations (t);
7234
7235   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
7236   fixup_attribute_variants (t);
7237
7238   /* Nadger the current location so that diagnostics point to the start of
7239      the struct, not the end.  */
7240   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
7241
7242   if (processing_template_decl)
7243     {
7244       tree x;
7245
7246       finish_struct_methods (t);
7247       TYPE_SIZE (t) = bitsize_zero_node;
7248       TYPE_SIZE_UNIT (t) = size_zero_node;
7249
7250       /* We need to emit an error message if this type was used as a parameter
7251          and it is an abstract type, even if it is a template. We construct
7252          a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
7253          account and we call complete_vars with this type, which will check
7254          the PARM_DECLS. Note that while the type is being defined,
7255          CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
7256          (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it.  */
7257       CLASSTYPE_PURE_VIRTUALS (t) = NULL;
7258       for (x = TYPE_METHODS (t); x; x = DECL_CHAIN (x))
7259         if (DECL_PURE_VIRTUAL_P (x))
7260           vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t), x);
7261       complete_vars (t);
7262       /* We need to add the target functions to the CLASSTYPE_METHOD_VEC if
7263          an enclosing scope is a template class, so that this function be
7264          found by lookup_fnfields_1 when the using declaration is not
7265          instantiated yet.  */
7266       for (x = TYPE_FIELDS (t); x; x = DECL_CHAIN (x))
7267         if (TREE_CODE (x) == USING_DECL)
7268           {
7269             tree fn = strip_using_decl (x);
7270             if (is_overloaded_fn (fn))
7271               for (; fn; fn = OVL_NEXT (fn))
7272                 add_method (t, OVL_CURRENT (fn), x);
7273           }
7274
7275       /* Remember current #pragma pack value.  */
7276       TYPE_PRECISION (t) = maximum_field_alignment;
7277
7278       /* Fix up any variants we've already built.  */
7279       for (x = TYPE_NEXT_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
7280         {
7281           TYPE_SIZE (x) = TYPE_SIZE (t);
7282           TYPE_SIZE_UNIT (x) = TYPE_SIZE_UNIT (t);
7283           TYPE_FIELDS (x) = TYPE_FIELDS (t);
7284           TYPE_METHODS (x) = TYPE_METHODS (t);
7285         }
7286     }
7287   else
7288     finish_struct_1 (t);
7289
7290   if (is_std_init_list (t))
7291     {
7292       /* People keep complaining that the compiler crashes on an invalid
7293          definition of initializer_list, so I guess we should explicitly
7294          reject it.  What the compiler internals care about is that it's a
7295          template and has a pointer field followed by an integer field.  */
7296       bool ok = false;
7297       if (processing_template_decl)
7298         {
7299           tree f = next_initializable_field (TYPE_FIELDS (t));
7300           if (f && TREE_CODE (TREE_TYPE (f)) == POINTER_TYPE)
7301             {
7302               f = next_initializable_field (DECL_CHAIN (f));
7303               if (f && same_type_p (TREE_TYPE (f), size_type_node))
7304                 ok = true;
7305             }
7306         }
7307       if (!ok)
7308         fatal_error (input_location,
7309                      "definition of std::initializer_list does not match "
7310                      "#include <initializer_list>");
7311     }
7312
7313   input_location = saved_loc;
7314
7315   TYPE_BEING_DEFINED (t) = 0;
7316
7317   if (current_class_type)
7318     popclass ();
7319   else
7320     error ("trying to finish struct, but kicked out due to previous parse errors");
7321
7322   if (processing_template_decl && at_function_scope_p ()
7323       /* Lambdas are defined by the LAMBDA_EXPR.  */
7324       && !LAMBDA_TYPE_P (t))
7325     add_stmt (build_min (TAG_DEFN, t));
7326
7327   return t;
7328 }
7329 \f
7330 /* Hash table to avoid endless recursion when handling references.  */
7331 static hash_table<nofree_ptr_hash<tree_node> > *fixed_type_or_null_ref_ht;
7332
7333 /* Return the dynamic type of INSTANCE, if known.
7334    Used to determine whether the virtual function table is needed
7335    or not.
7336
7337    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
7338    of our knowledge of its type.  *NONNULL should be initialized
7339    before this function is called.  */
7340
7341 static tree
7342 fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
7343 {
7344 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
7345
7346   switch (TREE_CODE (instance))
7347     {
7348     case INDIRECT_REF:
7349       if (POINTER_TYPE_P (TREE_TYPE (instance)))
7350         return NULL_TREE;
7351       else
7352         return RECUR (TREE_OPERAND (instance, 0));
7353
7354     case CALL_EXPR:
7355       /* This is a call to a constructor, hence it's never zero.  */
7356       if (TREE_HAS_CONSTRUCTOR (instance))
7357         {
7358           if (nonnull)
7359             *nonnull = 1;
7360           return TREE_TYPE (instance);
7361         }
7362       return NULL_TREE;
7363
7364     case SAVE_EXPR:
7365       /* This is a call to a constructor, hence it's never zero.  */
7366       if (TREE_HAS_CONSTRUCTOR (instance))
7367         {
7368           if (nonnull)
7369             *nonnull = 1;
7370           return TREE_TYPE (instance);
7371         }
7372       return RECUR (TREE_OPERAND (instance, 0));
7373
7374     case POINTER_PLUS_EXPR:
7375     case PLUS_EXPR:
7376     case MINUS_EXPR:
7377       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
7378         return RECUR (TREE_OPERAND (instance, 0));
7379       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
7380         /* Propagate nonnull.  */
7381         return RECUR (TREE_OPERAND (instance, 0));
7382
7383       return NULL_TREE;
7384
7385     CASE_CONVERT:
7386       return RECUR (TREE_OPERAND (instance, 0));
7387
7388     case ADDR_EXPR:
7389       instance = TREE_OPERAND (instance, 0);
7390       if (nonnull)
7391         {
7392           /* Just because we see an ADDR_EXPR doesn't mean we're dealing
7393              with a real object -- given &p->f, p can still be null.  */
7394           tree t = get_base_address (instance);
7395           /* ??? Probably should check DECL_WEAK here.  */
7396           if (t && DECL_P (t))
7397             *nonnull = 1;
7398         }
7399       return RECUR (instance);
7400
7401     case COMPONENT_REF:
7402       /* If this component is really a base class reference, then the field
7403          itself isn't definitive.  */
7404       if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
7405         return RECUR (TREE_OPERAND (instance, 0));
7406       return RECUR (TREE_OPERAND (instance, 1));
7407
7408     case VAR_DECL:
7409     case FIELD_DECL:
7410       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
7411           && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance))))
7412         {
7413           if (nonnull)
7414             *nonnull = 1;
7415           return TREE_TYPE (TREE_TYPE (instance));
7416         }
7417       /* fall through.  */
7418     case TARGET_EXPR:
7419     case PARM_DECL:
7420     case RESULT_DECL:
7421       if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance)))
7422         {
7423           if (nonnull)
7424             *nonnull = 1;
7425           return TREE_TYPE (instance);
7426         }
7427       else if (instance == current_class_ptr)
7428         {
7429           if (nonnull)
7430             *nonnull = 1;
7431
7432           /* if we're in a ctor or dtor, we know our type.  If
7433              current_class_ptr is set but we aren't in a function, we're in
7434              an NSDMI (and therefore a constructor).  */
7435           if (current_scope () != current_function_decl
7436               || (DECL_LANG_SPECIFIC (current_function_decl)
7437                   && (DECL_CONSTRUCTOR_P (current_function_decl)
7438                       || DECL_DESTRUCTOR_P (current_function_decl))))
7439             {
7440               if (cdtorp)
7441                 *cdtorp = 1;
7442               return TREE_TYPE (TREE_TYPE (instance));
7443             }
7444         }
7445       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
7446         {
7447           /* We only need one hash table because it is always left empty.  */
7448           if (!fixed_type_or_null_ref_ht)
7449             fixed_type_or_null_ref_ht
7450               = new hash_table<nofree_ptr_hash<tree_node> > (37);
7451
7452           /* Reference variables should be references to objects.  */
7453           if (nonnull)
7454             *nonnull = 1;
7455
7456           /* Enter the INSTANCE in a table to prevent recursion; a
7457              variable's initializer may refer to the variable
7458              itself.  */
7459           if (VAR_P (instance)
7460               && DECL_INITIAL (instance)
7461               && !type_dependent_expression_p_push (DECL_INITIAL (instance))
7462               && !fixed_type_or_null_ref_ht->find (instance))
7463             {
7464               tree type;
7465               tree_node **slot;
7466
7467               slot = fixed_type_or_null_ref_ht->find_slot (instance, INSERT);
7468               *slot = instance;
7469               type = RECUR (DECL_INITIAL (instance));
7470               fixed_type_or_null_ref_ht->remove_elt (instance);
7471
7472               return type;
7473             }
7474         }
7475       return NULL_TREE;
7476
7477     default:
7478       return NULL_TREE;
7479     }
7480 #undef RECUR
7481 }
7482
7483 /* Return nonzero if the dynamic type of INSTANCE is known, and
7484    equivalent to the static type.  We also handle the case where
7485    INSTANCE is really a pointer. Return negative if this is a
7486    ctor/dtor. There the dynamic type is known, but this might not be
7487    the most derived base of the original object, and hence virtual
7488    bases may not be laid out according to this type.
7489
7490    Used to determine whether the virtual function table is needed
7491    or not.
7492
7493    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
7494    of our knowledge of its type.  *NONNULL should be initialized
7495    before this function is called.  */
7496
7497 int
7498 resolves_to_fixed_type_p (tree instance, int* nonnull)
7499 {
7500   tree t = TREE_TYPE (instance);
7501   int cdtorp = 0;
7502   tree fixed;
7503
7504   /* processing_template_decl can be false in a template if we're in
7505      instantiate_non_dependent_expr, but we still want to suppress
7506      this check.  */
7507   if (in_template_function ())
7508     {
7509       /* In a template we only care about the type of the result.  */
7510       if (nonnull)
7511         *nonnull = true;
7512       return true;
7513     }
7514
7515   fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
7516   if (fixed == NULL_TREE)
7517     return 0;
7518   if (POINTER_TYPE_P (t))
7519     t = TREE_TYPE (t);
7520   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
7521     return 0;
7522   return cdtorp ? -1 : 1;
7523 }
7524
7525 \f
7526 void
7527 init_class_processing (void)
7528 {
7529   current_class_depth = 0;
7530   current_class_stack_size = 10;
7531   current_class_stack
7532     = XNEWVEC (struct class_stack_node, current_class_stack_size);
7533   vec_alloc (local_classes, 8);
7534   sizeof_biggest_empty_class = size_zero_node;
7535
7536   ridpointers[(int) RID_PUBLIC] = access_public_node;
7537   ridpointers[(int) RID_PRIVATE] = access_private_node;
7538   ridpointers[(int) RID_PROTECTED] = access_protected_node;
7539 }
7540
7541 /* Restore the cached PREVIOUS_CLASS_LEVEL.  */
7542
7543 static void
7544 restore_class_cache (void)
7545 {
7546   tree type;
7547
7548   /* We are re-entering the same class we just left, so we don't
7549      have to search the whole inheritance matrix to find all the
7550      decls to bind again.  Instead, we install the cached
7551      class_shadowed list and walk through it binding names.  */
7552   push_binding_level (previous_class_level);
7553   class_binding_level = previous_class_level;
7554   /* Restore IDENTIFIER_TYPE_VALUE.  */
7555   for (type = class_binding_level->type_shadowed;
7556        type;
7557        type = TREE_CHAIN (type))
7558     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
7559 }
7560
7561 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
7562    appropriate for TYPE.
7563
7564    So that we may avoid calls to lookup_name, we cache the _TYPE
7565    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
7566
7567    For multiple inheritance, we perform a two-pass depth-first search
7568    of the type lattice.  */
7569
7570 void
7571 pushclass (tree type)
7572 {
7573   class_stack_node_t csn;
7574
7575   type = TYPE_MAIN_VARIANT (type);
7576
7577   /* Make sure there is enough room for the new entry on the stack.  */
7578   if (current_class_depth + 1 >= current_class_stack_size)
7579     {
7580       current_class_stack_size *= 2;
7581       current_class_stack
7582         = XRESIZEVEC (struct class_stack_node, current_class_stack,
7583                       current_class_stack_size);
7584     }
7585
7586   /* Insert a new entry on the class stack.  */
7587   csn = current_class_stack + current_class_depth;
7588   csn->name = current_class_name;
7589   csn->type = current_class_type;
7590   csn->access = current_access_specifier;
7591   csn->names_used = 0;
7592   csn->hidden = 0;
7593   current_class_depth++;
7594
7595   /* Now set up the new type.  */
7596   current_class_name = TYPE_NAME (type);
7597   if (TREE_CODE (current_class_name) == TYPE_DECL)
7598     current_class_name = DECL_NAME (current_class_name);
7599   current_class_type = type;
7600
7601   /* By default, things in classes are private, while things in
7602      structures or unions are public.  */
7603   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
7604                               ? access_private_node
7605                               : access_public_node);
7606
7607   if (previous_class_level
7608       && type != previous_class_level->this_entity
7609       && current_class_depth == 1)
7610     {
7611       /* Forcibly remove any old class remnants.  */
7612       invalidate_class_lookup_cache ();
7613     }
7614
7615   if (!previous_class_level
7616       || type != previous_class_level->this_entity
7617       || current_class_depth > 1)
7618     pushlevel_class ();
7619   else
7620     restore_class_cache ();
7621 }
7622
7623 /* When we exit a toplevel class scope, we save its binding level so
7624    that we can restore it quickly.  Here, we've entered some other
7625    class, so we must invalidate our cache.  */
7626
7627 void
7628 invalidate_class_lookup_cache (void)
7629 {
7630   previous_class_level = NULL;
7631 }
7632
7633 /* Get out of the current class scope. If we were in a class scope
7634    previously, that is the one popped to.  */
7635
7636 void
7637 popclass (void)
7638 {
7639   poplevel_class ();
7640
7641   current_class_depth--;
7642   current_class_name = current_class_stack[current_class_depth].name;
7643   current_class_type = current_class_stack[current_class_depth].type;
7644   current_access_specifier = current_class_stack[current_class_depth].access;
7645   if (current_class_stack[current_class_depth].names_used)
7646     splay_tree_delete (current_class_stack[current_class_depth].names_used);
7647 }
7648
7649 /* Mark the top of the class stack as hidden.  */
7650
7651 void
7652 push_class_stack (void)
7653 {
7654   if (current_class_depth)
7655     ++current_class_stack[current_class_depth - 1].hidden;
7656 }
7657
7658 /* Mark the top of the class stack as un-hidden.  */
7659
7660 void
7661 pop_class_stack (void)
7662 {
7663   if (current_class_depth)
7664     --current_class_stack[current_class_depth - 1].hidden;
7665 }
7666
7667 /* Returns 1 if the class type currently being defined is either T or
7668    a nested type of T.  Returns the type from the current_class_stack,
7669    which might be equivalent to but not equal to T in case of
7670    constrained partial specializations.  */
7671
7672 tree
7673 currently_open_class (tree t)
7674 {
7675   int i;
7676
7677   if (!CLASS_TYPE_P (t))
7678     return NULL_TREE;
7679
7680   t = TYPE_MAIN_VARIANT (t);
7681
7682   /* We start looking from 1 because entry 0 is from global scope,
7683      and has no type.  */
7684   for (i = current_class_depth; i > 0; --i)
7685     {
7686       tree c;
7687       if (i == current_class_depth)
7688         c = current_class_type;
7689       else
7690         {
7691           if (current_class_stack[i].hidden)
7692             break;
7693           c = current_class_stack[i].type;
7694         }
7695       if (!c)
7696         continue;
7697       if (same_type_p (c, t))
7698         return c;
7699     }
7700   return NULL_TREE;
7701 }
7702
7703 /* If either current_class_type or one of its enclosing classes are derived
7704    from T, return the appropriate type.  Used to determine how we found
7705    something via unqualified lookup.  */
7706
7707 tree
7708 currently_open_derived_class (tree t)
7709 {
7710   int i;
7711
7712   /* The bases of a dependent type are unknown.  */
7713   if (dependent_type_p (t))
7714     return NULL_TREE;
7715
7716   if (!current_class_type)
7717     return NULL_TREE;
7718
7719   if (DERIVED_FROM_P (t, current_class_type))
7720     return current_class_type;
7721
7722   for (i = current_class_depth - 1; i > 0; --i)
7723     {
7724       if (current_class_stack[i].hidden)
7725         break;
7726       if (DERIVED_FROM_P (t, current_class_stack[i].type))
7727         return current_class_stack[i].type;
7728     }
7729
7730   return NULL_TREE;
7731 }
7732
7733 /* Return the outermost enclosing class type that is still open, or
7734    NULL_TREE.  */
7735
7736 tree
7737 outermost_open_class (void)
7738 {
7739   if (!current_class_type)
7740     return NULL_TREE;
7741   tree r = NULL_TREE;
7742   if (TYPE_BEING_DEFINED (current_class_type))
7743     r = current_class_type;
7744   for (int i = current_class_depth - 1; i > 0; --i)
7745     {
7746       if (current_class_stack[i].hidden)
7747         break;
7748       tree t = current_class_stack[i].type;
7749       if (!TYPE_BEING_DEFINED (t))
7750         break;
7751       r = t;
7752     }
7753   return r;
7754 }
7755
7756 /* Returns the innermost class type which is not a lambda closure type.  */
7757
7758 tree
7759 current_nonlambda_class_type (void)
7760 {
7761   int i;
7762
7763   /* We start looking from 1 because entry 0 is from global scope,
7764      and has no type.  */
7765   for (i = current_class_depth; i > 0; --i)
7766     {
7767       tree c;
7768       if (i == current_class_depth)
7769         c = current_class_type;
7770       else
7771         {
7772           if (current_class_stack[i].hidden)
7773             break;
7774           c = current_class_stack[i].type;
7775         }
7776       if (!c)
7777         continue;
7778       if (!LAMBDA_TYPE_P (c))
7779         return c;
7780     }
7781   return NULL_TREE;
7782 }
7783
7784 /* When entering a class scope, all enclosing class scopes' names with
7785    static meaning (static variables, static functions, types and
7786    enumerators) have to be visible.  This recursive function calls
7787    pushclass for all enclosing class contexts until global or a local
7788    scope is reached.  TYPE is the enclosed class.  */
7789
7790 void
7791 push_nested_class (tree type)
7792 {
7793   /* A namespace might be passed in error cases, like A::B:C.  */
7794   if (type == NULL_TREE
7795       || !CLASS_TYPE_P (type))
7796     return;
7797
7798   push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type)));
7799
7800   pushclass (type);
7801 }
7802
7803 /* Undoes a push_nested_class call.  */
7804
7805 void
7806 pop_nested_class (void)
7807 {
7808   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
7809
7810   popclass ();
7811   if (context && CLASS_TYPE_P (context))
7812     pop_nested_class ();
7813 }
7814
7815 /* Returns the number of extern "LANG" blocks we are nested within.  */
7816
7817 int
7818 current_lang_depth (void)
7819 {
7820   return vec_safe_length (current_lang_base);
7821 }
7822
7823 /* Set global variables CURRENT_LANG_NAME to appropriate value
7824    so that behavior of name-mangling machinery is correct.  */
7825
7826 void
7827 push_lang_context (tree name)
7828 {
7829   vec_safe_push (current_lang_base, current_lang_name);
7830
7831   if (name == lang_name_cplusplus)
7832     {
7833       current_lang_name = name;
7834     }
7835   else if (name == lang_name_java)
7836     {
7837       current_lang_name = name;
7838       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
7839          (See record_builtin_java_type in decl.c.)  However, that causes
7840          incorrect debug entries if these types are actually used.
7841          So we re-enable debug output after extern "Java".  */
7842       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
7843       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
7844       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
7845       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
7846       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
7847       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
7848       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
7849       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
7850     }
7851   else if (name == lang_name_c)
7852     {
7853       current_lang_name = name;
7854     }
7855   else
7856     error ("language string %<\"%E\"%> not recognized", name);
7857 }
7858
7859 /* Get out of the current language scope.  */
7860
7861 void
7862 pop_lang_context (void)
7863 {
7864   current_lang_name = current_lang_base->pop ();
7865 }
7866 \f
7867 /* Type instantiation routines.  */
7868
7869 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
7870    matches the TARGET_TYPE.  If there is no satisfactory match, return
7871    error_mark_node, and issue an error & warning messages under
7872    control of FLAGS.  Permit pointers to member function if FLAGS
7873    permits.  If TEMPLATE_ONLY, the name of the overloaded function was
7874    a template-id, and EXPLICIT_TARGS are the explicitly provided
7875    template arguments.
7876
7877    If OVERLOAD is for one or more member functions, then ACCESS_PATH
7878    is the base path used to reference those member functions.  If
7879    the address is resolved to a member function, access checks will be
7880    performed and errors issued if appropriate.  */
7881
7882 static tree
7883 resolve_address_of_overloaded_function (tree target_type,
7884                                         tree overload,
7885                                         tsubst_flags_t complain,
7886                                         bool template_only,
7887                                         tree explicit_targs,
7888                                         tree access_path)
7889 {
7890   /* Here's what the standard says:
7891
7892        [over.over]
7893
7894        If the name is a function template, template argument deduction
7895        is done, and if the argument deduction succeeds, the deduced
7896        arguments are used to generate a single template function, which
7897        is added to the set of overloaded functions considered.
7898
7899        Non-member functions and static member functions match targets of
7900        type "pointer-to-function" or "reference-to-function."  Nonstatic
7901        member functions match targets of type "pointer-to-member
7902        function;" the function type of the pointer to member is used to
7903        select the member function from the set of overloaded member
7904        functions.  If a nonstatic member function is selected, the
7905        reference to the overloaded function name is required to have the
7906        form of a pointer to member as described in 5.3.1.
7907
7908        If more than one function is selected, any template functions in
7909        the set are eliminated if the set also contains a non-template
7910        function, and any given template function is eliminated if the
7911        set contains a second template function that is more specialized
7912        than the first according to the partial ordering rules 14.5.5.2.
7913        After such eliminations, if any, there shall remain exactly one
7914        selected function.  */
7915
7916   int is_ptrmem = 0;
7917   /* We store the matches in a TREE_LIST rooted here.  The functions
7918      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
7919      interoperability with most_specialized_instantiation.  */
7920   tree matches = NULL_TREE;
7921   tree fn;
7922   tree target_fn_type;
7923
7924   /* By the time we get here, we should be seeing only real
7925      pointer-to-member types, not the internal POINTER_TYPE to
7926      METHOD_TYPE representation.  */
7927   gcc_assert (!TYPE_PTR_P (target_type)
7928               || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
7929
7930   gcc_assert (is_overloaded_fn (overload));
7931
7932   /* Check that the TARGET_TYPE is reasonable.  */
7933   if (TYPE_PTRFN_P (target_type)
7934       || TYPE_REFFN_P (target_type))
7935     /* This is OK.  */;
7936   else if (TYPE_PTRMEMFUNC_P (target_type))
7937     /* This is OK, too.  */
7938     is_ptrmem = 1;
7939   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
7940     /* This is OK, too.  This comes from a conversion to reference
7941        type.  */
7942     target_type = build_reference_type (target_type);
7943   else
7944     {
7945       if (complain & tf_error)
7946         error ("cannot resolve overloaded function %qD based on"
7947                " conversion to type %qT",
7948                DECL_NAME (OVL_FUNCTION (overload)), target_type);
7949       return error_mark_node;
7950     }
7951
7952   /* Non-member functions and static member functions match targets of type
7953      "pointer-to-function" or "reference-to-function."  Nonstatic member
7954      functions match targets of type "pointer-to-member-function;" the
7955      function type of the pointer to member is used to select the member
7956      function from the set of overloaded member functions.
7957
7958      So figure out the FUNCTION_TYPE that we want to match against.  */
7959   target_fn_type = static_fn_type (target_type);
7960
7961   /* If we can find a non-template function that matches, we can just
7962      use it.  There's no point in generating template instantiations
7963      if we're just going to throw them out anyhow.  But, of course, we
7964      can only do this when we don't *need* a template function.  */
7965   if (!template_only)
7966     {
7967       tree fns;
7968
7969       for (fns = overload; fns; fns = OVL_NEXT (fns))
7970         {
7971           tree fn = OVL_CURRENT (fns);
7972
7973           if (TREE_CODE (fn) == TEMPLATE_DECL)
7974             /* We're not looking for templates just yet.  */
7975             continue;
7976
7977           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
7978               != is_ptrmem)
7979             /* We're looking for a non-static member, and this isn't
7980                one, or vice versa.  */
7981             continue;
7982
7983           /* Ignore functions which haven't been explicitly
7984              declared.  */
7985           if (DECL_ANTICIPATED (fn))
7986             continue;
7987
7988           /* See if there's a match.  */
7989           tree fntype = static_fn_type (fn);
7990           if (same_type_p (target_fn_type, fntype)
7991               || can_convert_tx_safety (target_fn_type, fntype))
7992             matches = tree_cons (fn, NULL_TREE, matches);
7993         }
7994     }
7995
7996   /* Now, if we've already got a match (or matches), there's no need
7997      to proceed to the template functions.  But, if we don't have a
7998      match we need to look at them, too.  */
7999   if (!matches)
8000     {
8001       tree target_arg_types;
8002       tree target_ret_type;
8003       tree fns;
8004       tree *args;
8005       unsigned int nargs, ia;
8006       tree arg;
8007
8008       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
8009       target_ret_type = TREE_TYPE (target_fn_type);
8010
8011       nargs = list_length (target_arg_types);
8012       args = XALLOCAVEC (tree, nargs);
8013       for (arg = target_arg_types, ia = 0;
8014            arg != NULL_TREE && arg != void_list_node;
8015            arg = TREE_CHAIN (arg), ++ia)
8016         args[ia] = TREE_VALUE (arg);
8017       nargs = ia;
8018
8019       for (fns = overload; fns; fns = OVL_NEXT (fns))
8020         {
8021           tree fn = OVL_CURRENT (fns);
8022           tree instantiation;
8023           tree targs;
8024
8025           if (TREE_CODE (fn) != TEMPLATE_DECL)
8026             /* We're only looking for templates.  */
8027             continue;
8028
8029           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
8030               != is_ptrmem)
8031             /* We're not looking for a non-static member, and this is
8032                one, or vice versa.  */
8033             continue;
8034
8035           tree ret = target_ret_type;
8036
8037           /* If the template has a deduced return type, don't expose it to
8038              template argument deduction.  */
8039           if (undeduced_auto_decl (fn))
8040             ret = NULL_TREE;
8041
8042           /* Try to do argument deduction.  */
8043           targs = make_tree_vec (DECL_NTPARMS (fn));
8044           instantiation = fn_type_unification (fn, explicit_targs, targs, args,
8045                                                nargs, ret,
8046                                               DEDUCE_EXACT, LOOKUP_NORMAL,
8047                                                false, false);
8048           if (instantiation == error_mark_node)
8049             /* Instantiation failed.  */
8050             continue;
8051
8052           /* Constraints must be satisfied. This is done before
8053              return type deduction since that instantiates the
8054              function. */
8055           if (flag_concepts && !constraints_satisfied_p (instantiation))
8056             continue;
8057
8058           /* And now force instantiation to do return type deduction.  */
8059           if (undeduced_auto_decl (instantiation))
8060             {
8061               ++function_depth;
8062               instantiate_decl (instantiation, /*defer*/false, /*class*/false);
8063               --function_depth;
8064
8065               require_deduced_type (instantiation);
8066             }
8067
8068           /* See if there's a match.  */
8069           tree fntype = static_fn_type (instantiation);
8070           if (same_type_p (target_fn_type, fntype)
8071               || can_convert_tx_safety (target_fn_type, fntype))
8072             matches = tree_cons (instantiation, fn, matches);
8073         }
8074
8075       /* Now, remove all but the most specialized of the matches.  */
8076       if (matches)
8077         {
8078           tree match = most_specialized_instantiation (matches);
8079
8080           if (match != error_mark_node)
8081             matches = tree_cons (TREE_PURPOSE (match),
8082                                  NULL_TREE,
8083                                  NULL_TREE);
8084         }
8085     }
8086
8087   /* Now we should have exactly one function in MATCHES.  */
8088   if (matches == NULL_TREE)
8089     {
8090       /* There were *no* matches.  */
8091       if (complain & tf_error)
8092         {
8093           error ("no matches converting function %qD to type %q#T",
8094                  DECL_NAME (OVL_CURRENT (overload)),
8095                  target_type);
8096
8097           print_candidates (overload);
8098         }
8099       return error_mark_node;
8100     }
8101   else if (TREE_CHAIN (matches))
8102     {
8103       /* There were too many matches.  First check if they're all
8104          the same function.  */
8105       tree match = NULL_TREE;
8106
8107       fn = TREE_PURPOSE (matches);
8108
8109       /* For multi-versioned functions, more than one match is just fine and
8110          decls_match will return false as they are different.  */
8111       for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match))
8112         if (!decls_match (fn, TREE_PURPOSE (match))
8113             && !targetm.target_option.function_versions
8114                (fn, TREE_PURPOSE (match)))
8115           break;
8116
8117       if (match)
8118         {
8119           if (complain & tf_error)
8120             {
8121               error ("converting overloaded function %qD to type %q#T is ambiguous",
8122                      DECL_NAME (OVL_FUNCTION (overload)),
8123                      target_type);
8124
8125               /* Since print_candidates expects the functions in the
8126                  TREE_VALUE slot, we flip them here.  */
8127               for (match = matches; match; match = TREE_CHAIN (match))
8128                 TREE_VALUE (match) = TREE_PURPOSE (match);
8129
8130               print_candidates (matches);
8131             }
8132
8133           return error_mark_node;
8134         }
8135     }
8136
8137   /* Good, exactly one match.  Now, convert it to the correct type.  */
8138   fn = TREE_PURPOSE (matches);
8139
8140   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
8141       && !(complain & tf_ptrmem_ok) && !flag_ms_extensions)
8142     {
8143       static int explained;
8144
8145       if (!(complain & tf_error))
8146         return error_mark_node;
8147
8148       permerror (input_location, "assuming pointer to member %qD", fn);
8149       if (!explained)
8150         {
8151           inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
8152           explained = 1;
8153         }
8154     }
8155
8156   /* If a pointer to a function that is multi-versioned is requested, the
8157      pointer to the dispatcher function is returned instead.  This works
8158      well because indirectly calling the function will dispatch the right
8159      function version at run-time.  */
8160   if (DECL_FUNCTION_VERSIONED (fn))
8161     {
8162       fn = get_function_version_dispatcher (fn);
8163       if (fn == NULL)
8164         return error_mark_node;
8165       /* Mark all the versions corresponding to the dispatcher as used.  */
8166       if (!(complain & tf_conv))
8167         mark_versions_used (fn);
8168     }
8169
8170   /* If we're doing overload resolution purely for the purpose of
8171      determining conversion sequences, we should not consider the
8172      function used.  If this conversion sequence is selected, the
8173      function will be marked as used at this point.  */
8174   if (!(complain & tf_conv))
8175     {
8176       /* Make =delete work with SFINAE.  */
8177       if (DECL_DELETED_FN (fn) && !(complain & tf_error))
8178         return error_mark_node;
8179       if (!mark_used (fn, complain) && !(complain & tf_error))
8180         return error_mark_node;
8181     }
8182
8183   /* We could not check access to member functions when this
8184      expression was originally created since we did not know at that
8185      time to which function the expression referred.  */
8186   if (DECL_FUNCTION_MEMBER_P (fn))
8187     {
8188       gcc_assert (access_path);
8189       perform_or_defer_access_check (access_path, fn, fn, complain);
8190     }
8191
8192   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
8193     return cp_build_addr_expr (fn, complain);
8194   else
8195     {
8196       /* The target must be a REFERENCE_TYPE.  Above, cp_build_unary_op
8197          will mark the function as addressed, but here we must do it
8198          explicitly.  */
8199       cxx_mark_addressable (fn);
8200
8201       return fn;
8202     }
8203 }
8204
8205 /* This function will instantiate the type of the expression given in
8206    RHS to match the type of LHSTYPE.  If errors exist, then return
8207    error_mark_node. COMPLAIN is a bit mask.  If TF_ERROR is set, then
8208    we complain on errors.  If we are not complaining, never modify rhs,
8209    as overload resolution wants to try many possible instantiations, in
8210    the hope that at least one will work.
8211
8212    For non-recursive calls, LHSTYPE should be a function, pointer to
8213    function, or a pointer to member function.  */
8214
8215 tree
8216 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t complain)
8217 {
8218   tsubst_flags_t complain_in = complain;
8219   tree access_path = NULL_TREE;
8220
8221   complain &= ~tf_ptrmem_ok;
8222
8223   if (lhstype == unknown_type_node)
8224     {
8225       if (complain & tf_error)
8226         error ("not enough type information");
8227       return error_mark_node;
8228     }
8229
8230   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
8231     {
8232       tree fntype = non_reference (lhstype);
8233       if (same_type_p (fntype, TREE_TYPE (rhs)))
8234         return rhs;
8235       if (flag_ms_extensions
8236           && TYPE_PTRMEMFUNC_P (fntype)
8237           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
8238         /* Microsoft allows `A::f' to be resolved to a
8239            pointer-to-member.  */
8240         ;
8241       else
8242         {
8243           if (complain & tf_error)
8244             error ("cannot convert %qE from type %qT to type %qT",
8245                    rhs, TREE_TYPE (rhs), fntype);
8246           return error_mark_node;
8247         }
8248     }
8249
8250   if (BASELINK_P (rhs))
8251     {
8252       access_path = BASELINK_ACCESS_BINFO (rhs);
8253       rhs = BASELINK_FUNCTIONS (rhs);
8254     }
8255
8256   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
8257      deduce any type information.  */
8258   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
8259     {
8260       if (complain & tf_error)
8261         error ("not enough type information");
8262       return error_mark_node;
8263     }
8264
8265   /* If we instantiate a template, and it is a A ?: C expression
8266      with omitted B, look through the SAVE_EXPR.  */
8267   if (TREE_CODE (rhs) == SAVE_EXPR)
8268     rhs = TREE_OPERAND (rhs, 0);
8269
8270   /* There are only a few kinds of expressions that may have a type
8271      dependent on overload resolution.  */
8272   gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
8273               || TREE_CODE (rhs) == COMPONENT_REF
8274               || is_overloaded_fn (rhs)
8275               || (flag_ms_extensions && TREE_CODE (rhs) == FUNCTION_DECL));
8276
8277   /* This should really only be used when attempting to distinguish
8278      what sort of a pointer to function we have.  For now, any
8279      arithmetic operation which is not supported on pointers
8280      is rejected as an error.  */
8281
8282   switch (TREE_CODE (rhs))
8283     {
8284     case COMPONENT_REF:
8285       {
8286         tree member = TREE_OPERAND (rhs, 1);
8287
8288         member = instantiate_type (lhstype, member, complain);
8289         if (member != error_mark_node
8290             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
8291           /* Do not lose object's side effects.  */
8292           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
8293                          TREE_OPERAND (rhs, 0), member);
8294         return member;
8295       }
8296
8297     case OFFSET_REF:
8298       rhs = TREE_OPERAND (rhs, 1);
8299       if (BASELINK_P (rhs))
8300         return instantiate_type (lhstype, rhs, complain_in);
8301
8302       /* This can happen if we are forming a pointer-to-member for a
8303          member template.  */
8304       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
8305
8306       /* Fall through.  */
8307
8308     case TEMPLATE_ID_EXPR:
8309       {
8310         tree fns = TREE_OPERAND (rhs, 0);
8311         tree args = TREE_OPERAND (rhs, 1);
8312
8313         return
8314           resolve_address_of_overloaded_function (lhstype, fns, complain_in,
8315                                                   /*template_only=*/true,
8316                                                   args, access_path);
8317       }
8318
8319     case OVERLOAD:
8320     case FUNCTION_DECL:
8321       return
8322         resolve_address_of_overloaded_function (lhstype, rhs, complain_in,
8323                                                 /*template_only=*/false,
8324                                                 /*explicit_targs=*/NULL_TREE,
8325                                                 access_path);
8326
8327     case ADDR_EXPR:
8328     {
8329       if (PTRMEM_OK_P (rhs))
8330         complain |= tf_ptrmem_ok;
8331
8332       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
8333     }
8334
8335     case ERROR_MARK:
8336       return error_mark_node;
8337
8338     default:
8339       gcc_unreachable ();
8340     }
8341   return error_mark_node;
8342 }
8343 \f
8344 /* Return the name of the virtual function pointer field
8345    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
8346    this may have to look back through base types to find the
8347    ultimate field name.  (For single inheritance, these could
8348    all be the same name.  Who knows for multiple inheritance).  */
8349
8350 static tree
8351 get_vfield_name (tree type)
8352 {
8353   tree binfo, base_binfo;
8354   char *buf;
8355
8356   for (binfo = TYPE_BINFO (type);
8357        BINFO_N_BASE_BINFOS (binfo);
8358        binfo = base_binfo)
8359     {
8360       base_binfo = BINFO_BASE_BINFO (binfo, 0);
8361
8362       if (BINFO_VIRTUAL_P (base_binfo)
8363           || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
8364         break;
8365     }
8366
8367   type = BINFO_TYPE (binfo);
8368   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
8369                          + TYPE_NAME_LENGTH (type) + 2);
8370   sprintf (buf, VFIELD_NAME_FORMAT,
8371            IDENTIFIER_POINTER (constructor_name (type)));
8372   return get_identifier (buf);
8373 }
8374
8375 void
8376 print_class_statistics (void)
8377 {
8378   if (! GATHER_STATISTICS)
8379     return;
8380
8381   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
8382   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
8383   if (n_vtables)
8384     {
8385       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
8386                n_vtables, n_vtable_searches);
8387       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
8388                n_vtable_entries, n_vtable_elems);
8389     }
8390 }
8391
8392 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
8393    according to [class]:
8394                                           The class-name is also inserted
8395    into  the scope of the class itself.  For purposes of access checking,
8396    the inserted class name is treated as if it were a public member name.  */
8397
8398 void
8399 build_self_reference (void)
8400 {
8401   tree name = constructor_name (current_class_type);
8402   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
8403   tree saved_cas;
8404
8405   DECL_NONLOCAL (value) = 1;
8406   DECL_CONTEXT (value) = current_class_type;
8407   DECL_ARTIFICIAL (value) = 1;
8408   SET_DECL_SELF_REFERENCE_P (value);
8409   set_underlying_type (value);
8410
8411   if (processing_template_decl)
8412     value = push_template_decl (value);
8413
8414   saved_cas = current_access_specifier;
8415   current_access_specifier = access_public_node;
8416   finish_member_declaration (value);
8417   current_access_specifier = saved_cas;
8418 }
8419
8420 /* Returns 1 if TYPE contains only padding bytes.  */
8421
8422 int
8423 is_empty_class (tree type)
8424 {
8425   if (type == error_mark_node)
8426     return 0;
8427
8428   if (! CLASS_TYPE_P (type))
8429     return 0;
8430
8431   return CLASSTYPE_EMPTY_P (type);
8432 }
8433
8434 /* Returns true if TYPE contains no actual data, just various
8435    possible combinations of empty classes and possibly a vptr.  */
8436
8437 bool
8438 is_really_empty_class (tree type)
8439 {
8440   if (CLASS_TYPE_P (type))
8441     {
8442       tree field;
8443       tree binfo;
8444       tree base_binfo;
8445       int i;
8446
8447       /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
8448          out, but we'd like to be able to check this before then.  */
8449       if (COMPLETE_TYPE_P (type) && is_empty_class (type))
8450         return true;
8451
8452       for (binfo = TYPE_BINFO (type), i = 0;
8453            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
8454         if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
8455           return false;
8456       for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
8457         if (TREE_CODE (field) == FIELD_DECL
8458             && !DECL_ARTIFICIAL (field)
8459             /* An unnamed bit-field is not a data member.  */
8460             && (DECL_NAME (field) || !DECL_C_BIT_FIELD (field))
8461             && !is_really_empty_class (TREE_TYPE (field)))
8462           return false;
8463       return true;
8464     }
8465   else if (TREE_CODE (type) == ARRAY_TYPE)
8466     return (integer_zerop (array_type_nelts_top (type))
8467             || is_really_empty_class (TREE_TYPE (type)));
8468   return false;
8469 }
8470
8471 /* Note that NAME was looked up while the current class was being
8472    defined and that the result of that lookup was DECL.  */
8473
8474 void
8475 maybe_note_name_used_in_class (tree name, tree decl)
8476 {
8477   splay_tree names_used;
8478
8479   /* If we're not defining a class, there's nothing to do.  */
8480   if (!(innermost_scope_kind() == sk_class
8481         && TYPE_BEING_DEFINED (current_class_type)
8482         && !LAMBDA_TYPE_P (current_class_type)))
8483     return;
8484
8485   /* If there's already a binding for this NAME, then we don't have
8486      anything to worry about.  */
8487   if (lookup_member (current_class_type, name,
8488                      /*protect=*/0, /*want_type=*/false, tf_warning_or_error))
8489     return;
8490
8491   if (!current_class_stack[current_class_depth - 1].names_used)
8492     current_class_stack[current_class_depth - 1].names_used
8493       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
8494   names_used = current_class_stack[current_class_depth - 1].names_used;
8495
8496   splay_tree_insert (names_used,
8497                      (splay_tree_key) name,
8498                      (splay_tree_value) decl);
8499 }
8500
8501 /* Note that NAME was declared (as DECL) in the current class.  Check
8502    to see that the declaration is valid.  */
8503
8504 void
8505 note_name_declared_in_class (tree name, tree decl)
8506 {
8507   splay_tree names_used;
8508   splay_tree_node n;
8509
8510   /* Look to see if we ever used this name.  */
8511   names_used
8512     = current_class_stack[current_class_depth - 1].names_used;
8513   if (!names_used)
8514     return;
8515   /* The C language allows members to be declared with a type of the same
8516      name, and the C++ standard says this diagnostic is not required.  So
8517      allow it in extern "C" blocks unless predantic is specified.
8518      Allow it in all cases if -ms-extensions is specified.  */
8519   if ((!pedantic && current_lang_name == lang_name_c)
8520       || flag_ms_extensions)
8521     return;
8522   n = splay_tree_lookup (names_used, (splay_tree_key) name);
8523   if (n)
8524     {
8525       /* [basic.scope.class]
8526
8527          A name N used in a class S shall refer to the same declaration
8528          in its context and when re-evaluated in the completed scope of
8529          S.  */
8530       permerror (input_location, "declaration of %q#D", decl);
8531       permerror (location_of ((tree) n->value),
8532                  "changes meaning of %qD from %q#D",
8533                  DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
8534     }
8535 }
8536
8537 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
8538    Secondary vtables are merged with primary vtables; this function
8539    will return the VAR_DECL for the primary vtable.  */
8540
8541 tree
8542 get_vtbl_decl_for_binfo (tree binfo)
8543 {
8544   tree decl;
8545
8546   decl = BINFO_VTABLE (binfo);
8547   if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR)
8548     {
8549       gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
8550       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
8551     }
8552   if (decl)
8553     gcc_assert (VAR_P (decl));
8554   return decl;
8555 }
8556
8557
8558 /* Returns the binfo for the primary base of BINFO.  If the resulting
8559    BINFO is a virtual base, and it is inherited elsewhere in the
8560    hierarchy, then the returned binfo might not be the primary base of
8561    BINFO in the complete object.  Check BINFO_PRIMARY_P or
8562    BINFO_LOST_PRIMARY_P to be sure.  */
8563
8564 static tree
8565 get_primary_binfo (tree binfo)
8566 {
8567   tree primary_base;
8568
8569   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
8570   if (!primary_base)
8571     return NULL_TREE;
8572
8573   return copied_binfo (primary_base, binfo);
8574 }
8575
8576 /* As above, but iterate until we reach the binfo that actually provides the
8577    vptr for BINFO.  */
8578
8579 static tree
8580 most_primary_binfo (tree binfo)
8581 {
8582   tree b = binfo;
8583   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
8584          && !BINFO_LOST_PRIMARY_P (b))
8585     {
8586       tree primary_base = get_primary_binfo (b);
8587       gcc_assert (BINFO_PRIMARY_P (primary_base)
8588                   && BINFO_INHERITANCE_CHAIN (primary_base) == b);
8589       b = primary_base;
8590     }
8591   return b;
8592 }
8593
8594 /* Returns true if BINFO gets its vptr from a virtual base of the most derived
8595    type.  Note that the virtual inheritance might be above or below BINFO in
8596    the hierarchy.  */
8597
8598 bool
8599 vptr_via_virtual_p (tree binfo)
8600 {
8601   if (TYPE_P (binfo))
8602     binfo = TYPE_BINFO (binfo);
8603   tree primary = most_primary_binfo (binfo);
8604   /* Don't limit binfo_via_virtual, we want to return true when BINFO itself is
8605      a morally virtual base.  */
8606   tree virt = binfo_via_virtual (primary, NULL_TREE);
8607   return virt != NULL_TREE;
8608 }
8609
8610 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
8611
8612 static int
8613 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
8614 {
8615   if (!indented_p)
8616     fprintf (stream, "%*s", indent, "");
8617   return 1;
8618 }
8619
8620 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
8621    INDENT should be zero when called from the top level; it is
8622    incremented recursively.  IGO indicates the next expected BINFO in
8623    inheritance graph ordering.  */
8624
8625 static tree
8626 dump_class_hierarchy_r (FILE *stream,
8627                         int flags,
8628                         tree binfo,
8629                         tree igo,
8630                         int indent)
8631 {
8632   int indented = 0;
8633   tree base_binfo;
8634   int i;
8635
8636   indented = maybe_indent_hierarchy (stream, indent, 0);
8637   fprintf (stream, "%s (0x" HOST_WIDE_INT_PRINT_HEX ") ",
8638            type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
8639            (HOST_WIDE_INT) (uintptr_t) binfo);
8640   if (binfo != igo)
8641     {
8642       fprintf (stream, "alternative-path\n");
8643       return igo;
8644     }
8645   igo = TREE_CHAIN (binfo);
8646
8647   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
8648            tree_to_shwi (BINFO_OFFSET (binfo)));
8649   if (is_empty_class (BINFO_TYPE (binfo)))
8650     fprintf (stream, " empty");
8651   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
8652     fprintf (stream, " nearly-empty");
8653   if (BINFO_VIRTUAL_P (binfo))
8654     fprintf (stream, " virtual");
8655   fprintf (stream, "\n");
8656
8657   indented = 0;
8658   if (BINFO_PRIMARY_P (binfo))
8659     {
8660       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
8661       fprintf (stream, " primary-for %s (0x" HOST_WIDE_INT_PRINT_HEX ")",
8662                type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
8663                                TFF_PLAIN_IDENTIFIER),
8664                (HOST_WIDE_INT) (uintptr_t) BINFO_INHERITANCE_CHAIN (binfo));
8665     }
8666   if (BINFO_LOST_PRIMARY_P (binfo))
8667     {
8668       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
8669       fprintf (stream, " lost-primary");
8670     }
8671   if (indented)
8672     fprintf (stream, "\n");
8673
8674   if (!(flags & TDF_SLIM))
8675     {
8676       int indented = 0;
8677
8678       if (BINFO_SUBVTT_INDEX (binfo))
8679         {
8680           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
8681           fprintf (stream, " subvttidx=%s",
8682                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
8683                                    TFF_PLAIN_IDENTIFIER));
8684         }
8685       if (BINFO_VPTR_INDEX (binfo))
8686         {
8687           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
8688           fprintf (stream, " vptridx=%s",
8689                    expr_as_string (BINFO_VPTR_INDEX (binfo),
8690                                    TFF_PLAIN_IDENTIFIER));
8691         }
8692       if (BINFO_VPTR_FIELD (binfo))
8693         {
8694           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
8695           fprintf (stream, " vbaseoffset=%s",
8696                    expr_as_string (BINFO_VPTR_FIELD (binfo),
8697                                    TFF_PLAIN_IDENTIFIER));
8698         }
8699       if (BINFO_VTABLE (binfo))
8700         {
8701           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
8702           fprintf (stream, " vptr=%s",
8703                    expr_as_string (BINFO_VTABLE (binfo),
8704                                    TFF_PLAIN_IDENTIFIER));
8705         }
8706
8707       if (indented)
8708         fprintf (stream, "\n");
8709     }
8710
8711   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
8712     igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
8713
8714   return igo;
8715 }
8716
8717 /* Dump the BINFO hierarchy for T.  */
8718
8719 static void
8720 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
8721 {
8722   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
8723   fprintf (stream, "   size=%lu align=%lu\n",
8724            (unsigned long)(tree_to_shwi (TYPE_SIZE (t)) / BITS_PER_UNIT),
8725            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
8726   fprintf (stream, "   base size=%lu base align=%lu\n",
8727            (unsigned long)(tree_to_shwi (TYPE_SIZE (CLASSTYPE_AS_BASE (t)))
8728                            / BITS_PER_UNIT),
8729            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
8730                            / BITS_PER_UNIT));
8731   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
8732   fprintf (stream, "\n");
8733 }
8734
8735 /* Debug interface to hierarchy dumping.  */
8736
8737 void
8738 debug_class (tree t)
8739 {
8740   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
8741 }
8742
8743 static void
8744 dump_class_hierarchy (tree t)
8745 {
8746   int flags;
8747   FILE *stream = get_dump_info (TDI_class, &flags);
8748
8749   if (stream)
8750     {
8751       dump_class_hierarchy_1 (stream, flags, t);
8752     }
8753 }
8754
8755 static void
8756 dump_array (FILE * stream, tree decl)
8757 {
8758   tree value;
8759   unsigned HOST_WIDE_INT ix;
8760   HOST_WIDE_INT elt;
8761   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
8762
8763   elt = (tree_to_shwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))))
8764          / BITS_PER_UNIT);
8765   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
8766   fprintf (stream, " %s entries",
8767            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
8768                            TFF_PLAIN_IDENTIFIER));
8769   fprintf (stream, "\n");
8770
8771   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
8772                               ix, value)
8773     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
8774              expr_as_string (value, TFF_PLAIN_IDENTIFIER));
8775 }
8776
8777 static void
8778 dump_vtable (tree t, tree binfo, tree vtable)
8779 {
8780   int flags;
8781   FILE *stream = get_dump_info (TDI_class, &flags);
8782
8783   if (!stream)
8784     return;
8785
8786   if (!(flags & TDF_SLIM))
8787     {
8788       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
8789
8790       fprintf (stream, "%s for %s",
8791                ctor_vtbl_p ? "Construction vtable" : "Vtable",
8792                type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
8793       if (ctor_vtbl_p)
8794         {
8795           if (!BINFO_VIRTUAL_P (binfo))
8796             fprintf (stream, " (0x" HOST_WIDE_INT_PRINT_HEX " instance)",
8797                      (HOST_WIDE_INT) (uintptr_t) binfo);
8798           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
8799         }
8800       fprintf (stream, "\n");
8801       dump_array (stream, vtable);
8802       fprintf (stream, "\n");
8803     }
8804 }
8805
8806 static void
8807 dump_vtt (tree t, tree vtt)
8808 {
8809   int flags;
8810   FILE *stream = get_dump_info (TDI_class, &flags);
8811
8812   if (!stream)
8813     return;
8814
8815   if (!(flags & TDF_SLIM))
8816     {
8817       fprintf (stream, "VTT for %s\n",
8818                type_as_string (t, TFF_PLAIN_IDENTIFIER));
8819       dump_array (stream, vtt);
8820       fprintf (stream, "\n");
8821     }
8822 }
8823
8824 /* Dump a function or thunk and its thunkees.  */
8825
8826 static void
8827 dump_thunk (FILE *stream, int indent, tree thunk)
8828 {
8829   static const char spaces[] = "        ";
8830   tree name = DECL_NAME (thunk);
8831   tree thunks;
8832
8833   fprintf (stream, "%.*s%p %s %s", indent, spaces,
8834            (void *)thunk,
8835            !DECL_THUNK_P (thunk) ? "function"
8836            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
8837            name ? IDENTIFIER_POINTER (name) : "<unset>");
8838   if (DECL_THUNK_P (thunk))
8839     {
8840       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
8841       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
8842
8843       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
8844       if (!virtual_adjust)
8845         /*NOP*/;
8846       else if (DECL_THIS_THUNK_P (thunk))
8847         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
8848                  tree_to_shwi (virtual_adjust));
8849       else
8850         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
8851                  tree_to_shwi (BINFO_VPTR_FIELD (virtual_adjust)),
8852                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
8853       if (THUNK_ALIAS (thunk))
8854         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
8855     }
8856   fprintf (stream, "\n");
8857   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
8858     dump_thunk (stream, indent + 2, thunks);
8859 }
8860
8861 /* Dump the thunks for FN.  */
8862
8863 void
8864 debug_thunks (tree fn)
8865 {
8866   dump_thunk (stderr, 0, fn);
8867 }
8868
8869 /* Virtual function table initialization.  */
8870
8871 /* Create all the necessary vtables for T and its base classes.  */
8872
8873 static void
8874 finish_vtbls (tree t)
8875 {
8876   tree vbase;
8877   vec<constructor_elt, va_gc> *v = NULL;
8878   tree vtable = BINFO_VTABLE (TYPE_BINFO (t));
8879
8880   /* We lay out the primary and secondary vtables in one contiguous
8881      vtable.  The primary vtable is first, followed by the non-virtual
8882      secondary vtables in inheritance graph order.  */
8883   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t), TYPE_BINFO (t),
8884                          vtable, t, &v);
8885
8886   /* Then come the virtual bases, also in inheritance graph order.  */
8887   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
8888     {
8889       if (!BINFO_VIRTUAL_P (vbase))
8890         continue;
8891       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), vtable, t, &v);
8892     }
8893
8894   if (BINFO_VTABLE (TYPE_BINFO (t)))
8895     initialize_vtable (TYPE_BINFO (t), v);
8896 }
8897
8898 /* Initialize the vtable for BINFO with the INITS.  */
8899
8900 static void
8901 initialize_vtable (tree binfo, vec<constructor_elt, va_gc> *inits)
8902 {
8903   tree decl;
8904
8905   layout_vtable_decl (binfo, vec_safe_length (inits));
8906   decl = get_vtbl_decl_for_binfo (binfo);
8907   initialize_artificial_var (decl, inits);
8908   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
8909 }
8910
8911 /* Build the VTT (virtual table table) for T.
8912    A class requires a VTT if it has virtual bases.
8913
8914    This holds
8915    1 - primary virtual pointer for complete object T
8916    2 - secondary VTTs for each direct non-virtual base of T which requires a
8917        VTT
8918    3 - secondary virtual pointers for each direct or indirect base of T which
8919        has virtual bases or is reachable via a virtual path from T.
8920    4 - secondary VTTs for each direct or indirect virtual base of T.
8921
8922    Secondary VTTs look like complete object VTTs without part 4.  */
8923
8924 static void
8925 build_vtt (tree t)
8926 {
8927   tree type;
8928   tree vtt;
8929   tree index;
8930   vec<constructor_elt, va_gc> *inits;
8931
8932   /* Build up the initializers for the VTT.  */
8933   inits = NULL;
8934   index = size_zero_node;
8935   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
8936
8937   /* If we didn't need a VTT, we're done.  */
8938   if (!inits)
8939     return;
8940
8941   /* Figure out the type of the VTT.  */
8942   type = build_array_of_n_type (const_ptr_type_node,
8943                                 inits->length ());
8944
8945   /* Now, build the VTT object itself.  */
8946   vtt = build_vtable (t, mangle_vtt_for_type (t), type);
8947   initialize_artificial_var (vtt, inits);
8948   /* Add the VTT to the vtables list.  */
8949   DECL_CHAIN (vtt) = DECL_CHAIN (CLASSTYPE_VTABLES (t));
8950   DECL_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
8951
8952   dump_vtt (t, vtt);
8953 }
8954
8955 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
8956    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
8957    and CHAIN the vtable pointer for this binfo after construction is
8958    complete.  VALUE can also be another BINFO, in which case we recurse.  */
8959
8960 static tree
8961 binfo_ctor_vtable (tree binfo)
8962 {
8963   tree vt;
8964
8965   while (1)
8966     {
8967       vt = BINFO_VTABLE (binfo);
8968       if (TREE_CODE (vt) == TREE_LIST)
8969         vt = TREE_VALUE (vt);
8970       if (TREE_CODE (vt) == TREE_BINFO)
8971         binfo = vt;
8972       else
8973         break;
8974     }
8975
8976   return vt;
8977 }
8978
8979 /* Data for secondary VTT initialization.  */
8980 struct secondary_vptr_vtt_init_data
8981 {
8982   /* Is this the primary VTT? */
8983   bool top_level_p;
8984
8985   /* Current index into the VTT.  */
8986   tree index;
8987
8988   /* Vector of initializers built up.  */
8989   vec<constructor_elt, va_gc> *inits;
8990
8991   /* The type being constructed by this secondary VTT.  */
8992   tree type_being_constructed;
8993 };
8994
8995 /* Recursively build the VTT-initializer for BINFO (which is in the
8996    hierarchy dominated by T).  INITS points to the end of the initializer
8997    list to date.  INDEX is the VTT index where the next element will be
8998    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
8999    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
9000    for virtual bases of T. When it is not so, we build the constructor
9001    vtables for the BINFO-in-T variant.  */
9002
9003 static void
9004 build_vtt_inits (tree binfo, tree t, vec<constructor_elt, va_gc> **inits,
9005                  tree *index)
9006 {
9007   int i;
9008   tree b;
9009   tree init;
9010   secondary_vptr_vtt_init_data data;
9011   int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
9012
9013   /* We only need VTTs for subobjects with virtual bases.  */
9014   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
9015     return;
9016
9017   /* We need to use a construction vtable if this is not the primary
9018      VTT.  */
9019   if (!top_level_p)
9020     {
9021       build_ctor_vtbl_group (binfo, t);
9022
9023       /* Record the offset in the VTT where this sub-VTT can be found.  */
9024       BINFO_SUBVTT_INDEX (binfo) = *index;
9025     }
9026
9027   /* Add the address of the primary vtable for the complete object.  */
9028   init = binfo_ctor_vtable (binfo);
9029   CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
9030   if (top_level_p)
9031     {
9032       gcc_assert (!BINFO_VPTR_INDEX (binfo));
9033       BINFO_VPTR_INDEX (binfo) = *index;
9034     }
9035   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
9036
9037   /* Recursively add the secondary VTTs for non-virtual bases.  */
9038   for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
9039     if (!BINFO_VIRTUAL_P (b))
9040       build_vtt_inits (b, t, inits, index);
9041
9042   /* Add secondary virtual pointers for all subobjects of BINFO with
9043      either virtual bases or reachable along a virtual path, except
9044      subobjects that are non-virtual primary bases.  */
9045   data.top_level_p = top_level_p;
9046   data.index = *index;
9047   data.inits = *inits;
9048   data.type_being_constructed = BINFO_TYPE (binfo);
9049
9050   dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
9051
9052   *index = data.index;
9053
9054   /* data.inits might have grown as we added secondary virtual pointers.
9055      Make sure our caller knows about the new vector.  */
9056   *inits = data.inits;
9057
9058   if (top_level_p)
9059     /* Add the secondary VTTs for virtual bases in inheritance graph
9060        order.  */
9061     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
9062       {
9063         if (!BINFO_VIRTUAL_P (b))
9064           continue;
9065
9066         build_vtt_inits (b, t, inits, index);
9067       }
9068   else
9069     /* Remove the ctor vtables we created.  */
9070     dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
9071 }
9072
9073 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo for the base
9074    in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure.  */
9075
9076 static tree
9077 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
9078 {
9079   secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
9080
9081   /* We don't care about bases that don't have vtables.  */
9082   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
9083     return dfs_skip_bases;
9084
9085   /* We're only interested in proper subobjects of the type being
9086      constructed.  */
9087   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
9088     return NULL_TREE;
9089
9090   /* We're only interested in bases with virtual bases or reachable
9091      via a virtual path from the type being constructed.  */
9092   if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
9093         || binfo_via_virtual (binfo, data->type_being_constructed)))
9094     return dfs_skip_bases;
9095
9096   /* We're not interested in non-virtual primary bases.  */
9097   if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
9098     return NULL_TREE;
9099
9100   /* Record the index where this secondary vptr can be found.  */
9101   if (data->top_level_p)
9102     {
9103       gcc_assert (!BINFO_VPTR_INDEX (binfo));
9104       BINFO_VPTR_INDEX (binfo) = data->index;
9105
9106       if (BINFO_VIRTUAL_P (binfo))
9107         {
9108           /* It's a primary virtual base, and this is not a
9109              construction vtable.  Find the base this is primary of in
9110              the inheritance graph, and use that base's vtable
9111              now.  */
9112           while (BINFO_PRIMARY_P (binfo))
9113             binfo = BINFO_INHERITANCE_CHAIN (binfo);
9114         }
9115     }
9116
9117   /* Add the initializer for the secondary vptr itself.  */
9118   CONSTRUCTOR_APPEND_ELT (data->inits, NULL_TREE, binfo_ctor_vtable (binfo));
9119
9120   /* Advance the vtt index.  */
9121   data->index = size_binop (PLUS_EXPR, data->index,
9122                             TYPE_SIZE_UNIT (ptr_type_node));
9123
9124   return NULL_TREE;
9125 }
9126
9127 /* Called from build_vtt_inits via dfs_walk. After building
9128    constructor vtables and generating the sub-vtt from them, we need
9129    to restore the BINFO_VTABLES that were scribbled on.  DATA is the
9130    binfo of the base whose sub vtt was generated.  */
9131
9132 static tree
9133 dfs_fixup_binfo_vtbls (tree binfo, void* data)
9134 {
9135   tree vtable = BINFO_VTABLE (binfo);
9136
9137   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
9138     /* If this class has no vtable, none of its bases do.  */
9139     return dfs_skip_bases;
9140
9141   if (!vtable)
9142     /* This might be a primary base, so have no vtable in this
9143        hierarchy.  */
9144     return NULL_TREE;
9145
9146   /* If we scribbled the construction vtable vptr into BINFO, clear it
9147      out now.  */
9148   if (TREE_CODE (vtable) == TREE_LIST
9149       && (TREE_PURPOSE (vtable) == (tree) data))
9150     BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
9151
9152   return NULL_TREE;
9153 }
9154
9155 /* Build the construction vtable group for BINFO which is in the
9156    hierarchy dominated by T.  */
9157
9158 static void
9159 build_ctor_vtbl_group (tree binfo, tree t)
9160 {
9161   tree type;
9162   tree vtbl;
9163   tree id;
9164   tree vbase;
9165   vec<constructor_elt, va_gc> *v;
9166
9167   /* See if we've already created this construction vtable group.  */
9168   id = mangle_ctor_vtbl_for_type (t, binfo);
9169   if (IDENTIFIER_GLOBAL_VALUE (id))
9170     return;
9171
9172   gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
9173   /* Build a version of VTBL (with the wrong type) for use in
9174      constructing the addresses of secondary vtables in the
9175      construction vtable group.  */
9176   vtbl = build_vtable (t, id, ptr_type_node);
9177   DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
9178   /* Don't export construction vtables from shared libraries.  Even on
9179      targets that don't support hidden visibility, this tells
9180      can_refer_decl_in_current_unit_p not to assume that it's safe to
9181      access from a different compilation unit (bz 54314).  */
9182   DECL_VISIBILITY (vtbl) = VISIBILITY_HIDDEN;
9183   DECL_VISIBILITY_SPECIFIED (vtbl) = true;
9184
9185   v = NULL;
9186   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
9187                          binfo, vtbl, t, &v);
9188
9189   /* Add the vtables for each of our virtual bases using the vbase in T
9190      binfo.  */
9191   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
9192        vbase;
9193        vbase = TREE_CHAIN (vbase))
9194     {
9195       tree b;
9196
9197       if (!BINFO_VIRTUAL_P (vbase))
9198         continue;
9199       b = copied_binfo (vbase, binfo);
9200
9201       accumulate_vtbl_inits (b, vbase, binfo, vtbl, t, &v);
9202     }
9203
9204   /* Figure out the type of the construction vtable.  */
9205   type = build_array_of_n_type (vtable_entry_type, v->length ());
9206   layout_type (type);
9207   TREE_TYPE (vtbl) = type;
9208   DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE;
9209   layout_decl (vtbl, 0);
9210
9211   /* Initialize the construction vtable.  */
9212   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
9213   initialize_artificial_var (vtbl, v);
9214   dump_vtable (t, binfo, vtbl);
9215 }
9216
9217 /* Add the vtbl initializers for BINFO (and its bases other than
9218    non-virtual primaries) to the list of INITS.  BINFO is in the
9219    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
9220    the constructor the vtbl inits should be accumulated for. (If this
9221    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
9222    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
9223    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
9224    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
9225    but are not necessarily the same in terms of layout.  */
9226
9227 static void
9228 accumulate_vtbl_inits (tree binfo,
9229                        tree orig_binfo,
9230                        tree rtti_binfo,
9231                        tree vtbl,
9232                        tree t,
9233                        vec<constructor_elt, va_gc> **inits)
9234 {
9235   int i;
9236   tree base_binfo;
9237   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
9238
9239   gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
9240
9241   /* If it doesn't have a vptr, we don't do anything.  */
9242   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
9243     return;
9244
9245   /* If we're building a construction vtable, we're not interested in
9246      subobjects that don't require construction vtables.  */
9247   if (ctor_vtbl_p
9248       && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
9249       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
9250     return;
9251
9252   /* Build the initializers for the BINFO-in-T vtable.  */
9253   dfs_accumulate_vtbl_inits (binfo, orig_binfo, rtti_binfo, vtbl, t, inits);
9254
9255   /* Walk the BINFO and its bases.  We walk in preorder so that as we
9256      initialize each vtable we can figure out at what offset the
9257      secondary vtable lies from the primary vtable.  We can't use
9258      dfs_walk here because we need to iterate through bases of BINFO
9259      and RTTI_BINFO simultaneously.  */
9260   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
9261     {
9262       /* Skip virtual bases.  */
9263       if (BINFO_VIRTUAL_P (base_binfo))
9264         continue;
9265       accumulate_vtbl_inits (base_binfo,
9266                              BINFO_BASE_BINFO (orig_binfo, i),
9267                              rtti_binfo, vtbl, t,
9268                              inits);
9269     }
9270 }
9271
9272 /* Called from accumulate_vtbl_inits.  Adds the initializers for the
9273    BINFO vtable to L.  */
9274
9275 static void
9276 dfs_accumulate_vtbl_inits (tree binfo,
9277                            tree orig_binfo,
9278                            tree rtti_binfo,
9279                            tree orig_vtbl,
9280                            tree t,
9281                            vec<constructor_elt, va_gc> **l)
9282 {
9283   tree vtbl = NULL_TREE;
9284   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
9285   int n_inits;
9286
9287   if (ctor_vtbl_p
9288       && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
9289     {
9290       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
9291          primary virtual base.  If it is not the same primary in
9292          the hierarchy of T, we'll need to generate a ctor vtable
9293          for it, to place at its location in T.  If it is the same
9294          primary, we still need a VTT entry for the vtable, but it
9295          should point to the ctor vtable for the base it is a
9296          primary for within the sub-hierarchy of RTTI_BINFO.
9297
9298          There are three possible cases:
9299
9300          1) We are in the same place.
9301          2) We are a primary base within a lost primary virtual base of
9302          RTTI_BINFO.
9303          3) We are primary to something not a base of RTTI_BINFO.  */
9304
9305       tree b;
9306       tree last = NULL_TREE;
9307
9308       /* First, look through the bases we are primary to for RTTI_BINFO
9309          or a virtual base.  */
9310       b = binfo;
9311       while (BINFO_PRIMARY_P (b))
9312         {
9313           b = BINFO_INHERITANCE_CHAIN (b);
9314           last = b;
9315           if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
9316             goto found;
9317         }
9318       /* If we run out of primary links, keep looking down our
9319          inheritance chain; we might be an indirect primary.  */
9320       for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
9321         if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
9322           break;
9323     found:
9324
9325       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
9326          base B and it is a base of RTTI_BINFO, this is case 2.  In
9327          either case, we share our vtable with LAST, i.e. the
9328          derived-most base within B of which we are a primary.  */
9329       if (b == rtti_binfo
9330           || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
9331         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
9332            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
9333            binfo_ctor_vtable after everything's been set up.  */
9334         vtbl = last;
9335
9336       /* Otherwise, this is case 3 and we get our own.  */
9337     }
9338   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
9339     return;
9340
9341   n_inits = vec_safe_length (*l);
9342
9343   if (!vtbl)
9344     {
9345       tree index;
9346       int non_fn_entries;
9347
9348       /* Add the initializer for this vtable.  */
9349       build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
9350                               &non_fn_entries, l);
9351
9352       /* Figure out the position to which the VPTR should point.  */
9353       vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, orig_vtbl);
9354       index = size_binop (MULT_EXPR,
9355                           TYPE_SIZE_UNIT (vtable_entry_type),
9356                           size_int (non_fn_entries + n_inits));
9357       vtbl = fold_build_pointer_plus (vtbl, index);
9358     }
9359
9360   if (ctor_vtbl_p)
9361     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
9362        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
9363        straighten this out.  */
9364     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
9365   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
9366     /* Throw away any unneeded intializers.  */
9367     (*l)->truncate (n_inits);
9368   else
9369      /* For an ordinary vtable, set BINFO_VTABLE.  */
9370     BINFO_VTABLE (binfo) = vtbl;
9371 }
9372
9373 static GTY(()) tree abort_fndecl_addr;
9374
9375 /* Construct the initializer for BINFO's virtual function table.  BINFO
9376    is part of the hierarchy dominated by T.  If we're building a
9377    construction vtable, the ORIG_BINFO is the binfo we should use to
9378    find the actual function pointers to put in the vtable - but they
9379    can be overridden on the path to most-derived in the graph that
9380    ORIG_BINFO belongs.  Otherwise,
9381    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
9382    BINFO that should be indicated by the RTTI information in the
9383    vtable; it will be a base class of T, rather than T itself, if we
9384    are building a construction vtable.
9385
9386    The value returned is a TREE_LIST suitable for wrapping in a
9387    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
9388    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
9389    number of non-function entries in the vtable.
9390
9391    It might seem that this function should never be called with a
9392    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
9393    base is always subsumed by a derived class vtable.  However, when
9394    we are building construction vtables, we do build vtables for
9395    primary bases; we need these while the primary base is being
9396    constructed.  */
9397
9398 static void
9399 build_vtbl_initializer (tree binfo,
9400                         tree orig_binfo,
9401                         tree t,
9402                         tree rtti_binfo,
9403                         int* non_fn_entries_p,
9404                         vec<constructor_elt, va_gc> **inits)
9405 {
9406   tree v;
9407   vtbl_init_data vid;
9408   unsigned ix, jx;
9409   tree vbinfo;
9410   vec<tree, va_gc> *vbases;
9411   constructor_elt *e;
9412
9413   /* Initialize VID.  */
9414   memset (&vid, 0, sizeof (vid));
9415   vid.binfo = binfo;
9416   vid.derived = t;
9417   vid.rtti_binfo = rtti_binfo;
9418   vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
9419   vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
9420   vid.generate_vcall_entries = true;
9421   /* The first vbase or vcall offset is at index -3 in the vtable.  */
9422   vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
9423
9424   /* Add entries to the vtable for RTTI.  */
9425   build_rtti_vtbl_entries (binfo, &vid);
9426
9427   /* Create an array for keeping track of the functions we've
9428      processed.  When we see multiple functions with the same
9429      signature, we share the vcall offsets.  */
9430   vec_alloc (vid.fns, 32);
9431   /* Add the vcall and vbase offset entries.  */
9432   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
9433
9434   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
9435      build_vbase_offset_vtbl_entries.  */
9436   for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
9437        vec_safe_iterate (vbases, ix, &vbinfo); ix++)
9438     BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
9439
9440   /* If the target requires padding between data entries, add that now.  */
9441   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
9442     {
9443       int n_entries = vec_safe_length (vid.inits);
9444
9445       vec_safe_grow (vid.inits, TARGET_VTABLE_DATA_ENTRY_DISTANCE * n_entries);
9446
9447       /* Move data entries into their new positions and add padding
9448          after the new positions.  Iterate backwards so we don't
9449          overwrite entries that we would need to process later.  */
9450       for (ix = n_entries - 1;
9451            vid.inits->iterate (ix, &e);
9452            ix--)
9453         {
9454           int j;
9455           int new_position = (TARGET_VTABLE_DATA_ENTRY_DISTANCE * ix
9456                               + (TARGET_VTABLE_DATA_ENTRY_DISTANCE - 1));
9457
9458           (*vid.inits)[new_position] = *e;
9459
9460           for (j = 1; j < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++j)
9461             {
9462               constructor_elt *f = &(*vid.inits)[new_position - j];
9463               f->index = NULL_TREE;
9464               f->value = build1 (NOP_EXPR, vtable_entry_type,
9465                                  null_pointer_node);
9466             }
9467         }
9468     }
9469
9470   if (non_fn_entries_p)
9471     *non_fn_entries_p = vec_safe_length (vid.inits);
9472
9473   /* The initializers for virtual functions were built up in reverse
9474      order.  Straighten them out and add them to the running list in one
9475      step.  */
9476   jx = vec_safe_length (*inits);
9477   vec_safe_grow (*inits, jx + vid.inits->length ());
9478
9479   for (ix = vid.inits->length () - 1;
9480        vid.inits->iterate (ix, &e);
9481        ix--, jx++)
9482     (**inits)[jx] = *e;
9483
9484   /* Go through all the ordinary virtual functions, building up
9485      initializers.  */
9486   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
9487     {
9488       tree delta;
9489       tree vcall_index;
9490       tree fn, fn_original;
9491       tree init = NULL_TREE;
9492
9493       fn = BV_FN (v);
9494       fn_original = fn;
9495       if (DECL_THUNK_P (fn))
9496         {
9497           if (!DECL_NAME (fn))
9498             finish_thunk (fn);
9499           if (THUNK_ALIAS (fn))
9500             {
9501               fn = THUNK_ALIAS (fn);
9502               BV_FN (v) = fn;
9503             }
9504           fn_original = THUNK_TARGET (fn);
9505         }
9506
9507       /* If the only definition of this function signature along our
9508          primary base chain is from a lost primary, this vtable slot will
9509          never be used, so just zero it out.  This is important to avoid
9510          requiring extra thunks which cannot be generated with the function.
9511
9512          We first check this in update_vtable_entry_for_fn, so we handle
9513          restored primary bases properly; we also need to do it here so we
9514          zero out unused slots in ctor vtables, rather than filling them
9515          with erroneous values (though harmless, apart from relocation
9516          costs).  */
9517       if (BV_LOST_PRIMARY (v))
9518         init = size_zero_node;
9519
9520       if (! init)
9521         {
9522           /* Pull the offset for `this', and the function to call, out of
9523              the list.  */
9524           delta = BV_DELTA (v);
9525           vcall_index = BV_VCALL_INDEX (v);
9526
9527           gcc_assert (TREE_CODE (delta) == INTEGER_CST);
9528           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
9529
9530           /* You can't call an abstract virtual function; it's abstract.
9531              So, we replace these functions with __pure_virtual.  */
9532           if (DECL_PURE_VIRTUAL_P (fn_original))
9533             {
9534               fn = abort_fndecl;
9535               if (!TARGET_VTABLE_USES_DESCRIPTORS)
9536                 {
9537                   if (abort_fndecl_addr == NULL)
9538                     abort_fndecl_addr
9539                       = fold_convert (vfunc_ptr_type_node,
9540                                       build_fold_addr_expr (fn));
9541                   init = abort_fndecl_addr;
9542                 }
9543             }
9544           /* Likewise for deleted virtuals.  */
9545           else if (DECL_DELETED_FN (fn_original))
9546             {
9547               fn = get_identifier ("__cxa_deleted_virtual");
9548               if (!get_global_value_if_present (fn, &fn))
9549                 fn = push_library_fn (fn, (build_function_type_list
9550                                            (void_type_node, NULL_TREE)),
9551                                       NULL_TREE, ECF_NORETURN);
9552               if (!TARGET_VTABLE_USES_DESCRIPTORS)
9553                 init = fold_convert (vfunc_ptr_type_node,
9554                                      build_fold_addr_expr (fn));
9555             }
9556           else
9557             {
9558               if (!integer_zerop (delta) || vcall_index)
9559                 {
9560                   fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
9561                   if (!DECL_NAME (fn))
9562                     finish_thunk (fn);
9563                 }
9564               /* Take the address of the function, considering it to be of an
9565                  appropriate generic type.  */
9566               if (!TARGET_VTABLE_USES_DESCRIPTORS)
9567                 init = fold_convert (vfunc_ptr_type_node,
9568                                      build_fold_addr_expr (fn));
9569               /* Don't refer to a virtual destructor from a constructor
9570                  vtable or a vtable for an abstract class, since destroying
9571                  an object under construction is undefined behavior and we
9572                  don't want it to be considered a candidate for speculative
9573                  devirtualization.  But do create the thunk for ABI
9574                  compliance.  */
9575               if (DECL_DESTRUCTOR_P (fn_original)
9576                   && (CLASSTYPE_PURE_VIRTUALS (DECL_CONTEXT (fn_original))
9577                       || orig_binfo != binfo))
9578                 init = size_zero_node;
9579             }
9580         }
9581
9582       /* And add it to the chain of initializers.  */
9583       if (TARGET_VTABLE_USES_DESCRIPTORS)
9584         {
9585           int i;
9586           if (init == size_zero_node)
9587             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
9588               CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
9589           else
9590             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
9591               {
9592                 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
9593                                      fn, build_int_cst (NULL_TREE, i));
9594                 TREE_CONSTANT (fdesc) = 1;
9595
9596                 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, fdesc);
9597               }
9598         }
9599       else
9600         CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
9601     }
9602 }
9603
9604 /* Adds to vid->inits the initializers for the vbase and vcall
9605    offsets in BINFO, which is in the hierarchy dominated by T.  */
9606
9607 static void
9608 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
9609 {
9610   tree b;
9611
9612   /* If this is a derived class, we must first create entries
9613      corresponding to the primary base class.  */
9614   b = get_primary_binfo (binfo);
9615   if (b)
9616     build_vcall_and_vbase_vtbl_entries (b, vid);
9617
9618   /* Add the vbase entries for this base.  */
9619   build_vbase_offset_vtbl_entries (binfo, vid);
9620   /* Add the vcall entries for this base.  */
9621   build_vcall_offset_vtbl_entries (binfo, vid);
9622 }
9623
9624 /* Returns the initializers for the vbase offset entries in the vtable
9625    for BINFO (which is part of the class hierarchy dominated by T), in
9626    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
9627    where the next vbase offset will go.  */
9628
9629 static void
9630 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
9631 {
9632   tree vbase;
9633   tree t;
9634   tree non_primary_binfo;
9635
9636   /* If there are no virtual baseclasses, then there is nothing to
9637      do.  */
9638   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
9639     return;
9640
9641   t = vid->derived;
9642
9643   /* We might be a primary base class.  Go up the inheritance hierarchy
9644      until we find the most derived class of which we are a primary base:
9645      it is the offset of that which we need to use.  */
9646   non_primary_binfo = binfo;
9647   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
9648     {
9649       tree b;
9650
9651       /* If we have reached a virtual base, then it must be a primary
9652          base (possibly multi-level) of vid->binfo, or we wouldn't
9653          have called build_vcall_and_vbase_vtbl_entries for it.  But it
9654          might be a lost primary, so just skip down to vid->binfo.  */
9655       if (BINFO_VIRTUAL_P (non_primary_binfo))
9656         {
9657           non_primary_binfo = vid->binfo;
9658           break;
9659         }
9660
9661       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
9662       if (get_primary_binfo (b) != non_primary_binfo)
9663         break;
9664       non_primary_binfo = b;
9665     }
9666
9667   /* Go through the virtual bases, adding the offsets.  */
9668   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
9669        vbase;
9670        vbase = TREE_CHAIN (vbase))
9671     {
9672       tree b;
9673       tree delta;
9674
9675       if (!BINFO_VIRTUAL_P (vbase))
9676         continue;
9677
9678       /* Find the instance of this virtual base in the complete
9679          object.  */
9680       b = copied_binfo (vbase, binfo);
9681
9682       /* If we've already got an offset for this virtual base, we
9683          don't need another one.  */
9684       if (BINFO_VTABLE_PATH_MARKED (b))
9685         continue;
9686       BINFO_VTABLE_PATH_MARKED (b) = 1;
9687
9688       /* Figure out where we can find this vbase offset.  */
9689       delta = size_binop (MULT_EXPR,
9690                           vid->index,
9691                           fold_convert (ssizetype,
9692                                    TYPE_SIZE_UNIT (vtable_entry_type)));
9693       if (vid->primary_vtbl_p)
9694         BINFO_VPTR_FIELD (b) = delta;
9695
9696       if (binfo != TYPE_BINFO (t))
9697         /* The vbase offset had better be the same.  */
9698         gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
9699
9700       /* The next vbase will come at a more negative offset.  */
9701       vid->index = size_binop (MINUS_EXPR, vid->index,
9702                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
9703
9704       /* The initializer is the delta from BINFO to this virtual base.
9705          The vbase offsets go in reverse inheritance-graph order, and
9706          we are walking in inheritance graph order so these end up in
9707          the right order.  */
9708       delta = size_diffop_loc (input_location,
9709                            BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
9710
9711       CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE,
9712                               fold_build1_loc (input_location, NOP_EXPR,
9713                                                vtable_entry_type, delta));
9714     }
9715 }
9716
9717 /* Adds the initializers for the vcall offset entries in the vtable
9718    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
9719    to VID->INITS.  */
9720
9721 static void
9722 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
9723 {
9724   /* We only need these entries if this base is a virtual base.  We
9725      compute the indices -- but do not add to the vtable -- when
9726      building the main vtable for a class.  */
9727   if (binfo == TYPE_BINFO (vid->derived)
9728       || (BINFO_VIRTUAL_P (binfo)
9729           /* If BINFO is RTTI_BINFO, then (since BINFO does not
9730              correspond to VID->DERIVED), we are building a primary
9731              construction virtual table.  Since this is a primary
9732              virtual table, we do not need the vcall offsets for
9733              BINFO.  */
9734           && binfo != vid->rtti_binfo))
9735     {
9736       /* We need a vcall offset for each of the virtual functions in this
9737          vtable.  For example:
9738
9739            class A { virtual void f (); };
9740            class B1 : virtual public A { virtual void f (); };
9741            class B2 : virtual public A { virtual void f (); };
9742            class C: public B1, public B2 { virtual void f (); };
9743
9744          A C object has a primary base of B1, which has a primary base of A.  A
9745          C also has a secondary base of B2, which no longer has a primary base
9746          of A.  So the B2-in-C construction vtable needs a secondary vtable for
9747          A, which will adjust the A* to a B2* to call f.  We have no way of
9748          knowing what (or even whether) this offset will be when we define B2,
9749          so we store this "vcall offset" in the A sub-vtable and look it up in
9750          a "virtual thunk" for B2::f.
9751
9752          We need entries for all the functions in our primary vtable and
9753          in our non-virtual bases' secondary vtables.  */
9754       vid->vbase = binfo;
9755       /* If we are just computing the vcall indices -- but do not need
9756          the actual entries -- not that.  */
9757       if (!BINFO_VIRTUAL_P (binfo))
9758         vid->generate_vcall_entries = false;
9759       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
9760       add_vcall_offset_vtbl_entries_r (binfo, vid);
9761     }
9762 }
9763
9764 /* Build vcall offsets, starting with those for BINFO.  */
9765
9766 static void
9767 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
9768 {
9769   int i;
9770   tree primary_binfo;
9771   tree base_binfo;
9772
9773   /* Don't walk into virtual bases -- except, of course, for the
9774      virtual base for which we are building vcall offsets.  Any
9775      primary virtual base will have already had its offsets generated
9776      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
9777   if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
9778     return;
9779
9780   /* If BINFO has a primary base, process it first.  */
9781   primary_binfo = get_primary_binfo (binfo);
9782   if (primary_binfo)
9783     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
9784
9785   /* Add BINFO itself to the list.  */
9786   add_vcall_offset_vtbl_entries_1 (binfo, vid);
9787
9788   /* Scan the non-primary bases of BINFO.  */
9789   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
9790     if (base_binfo != primary_binfo)
9791       add_vcall_offset_vtbl_entries_r (base_binfo, vid);
9792 }
9793
9794 /* Called from build_vcall_offset_vtbl_entries_r.  */
9795
9796 static void
9797 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
9798 {
9799   /* Make entries for the rest of the virtuals.  */
9800   tree orig_fn;
9801
9802   /* The ABI requires that the methods be processed in declaration
9803      order.  */
9804   for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
9805        orig_fn;
9806        orig_fn = DECL_CHAIN (orig_fn))
9807     if (TREE_CODE (orig_fn) == FUNCTION_DECL && DECL_VINDEX (orig_fn))
9808       add_vcall_offset (orig_fn, binfo, vid);
9809 }
9810
9811 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
9812
9813 static void
9814 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
9815 {
9816   size_t i;
9817   tree vcall_offset;
9818   tree derived_entry;
9819
9820   /* If there is already an entry for a function with the same
9821      signature as FN, then we do not need a second vcall offset.
9822      Check the list of functions already present in the derived
9823      class vtable.  */
9824   FOR_EACH_VEC_SAFE_ELT (vid->fns, i, derived_entry)
9825     {
9826       if (same_signature_p (derived_entry, orig_fn)
9827           /* We only use one vcall offset for virtual destructors,
9828              even though there are two virtual table entries.  */
9829           || (DECL_DESTRUCTOR_P (derived_entry)
9830               && DECL_DESTRUCTOR_P (orig_fn)))
9831         return;
9832     }
9833
9834   /* If we are building these vcall offsets as part of building
9835      the vtable for the most derived class, remember the vcall
9836      offset.  */
9837   if (vid->binfo == TYPE_BINFO (vid->derived))
9838     {
9839       tree_pair_s elt = {orig_fn, vid->index};
9840       vec_safe_push (CLASSTYPE_VCALL_INDICES (vid->derived), elt);
9841     }
9842
9843   /* The next vcall offset will be found at a more negative
9844      offset.  */
9845   vid->index = size_binop (MINUS_EXPR, vid->index,
9846                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
9847
9848   /* Keep track of this function.  */
9849   vec_safe_push (vid->fns, orig_fn);
9850
9851   if (vid->generate_vcall_entries)
9852     {
9853       tree base;
9854       tree fn;
9855
9856       /* Find the overriding function.  */
9857       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
9858       if (fn == error_mark_node)
9859         vcall_offset = build_zero_cst (vtable_entry_type);
9860       else
9861         {
9862           base = TREE_VALUE (fn);
9863
9864           /* The vbase we're working on is a primary base of
9865              vid->binfo.  But it might be a lost primary, so its
9866              BINFO_OFFSET might be wrong, so we just use the
9867              BINFO_OFFSET from vid->binfo.  */
9868           vcall_offset = size_diffop_loc (input_location,
9869                                       BINFO_OFFSET (base),
9870                                       BINFO_OFFSET (vid->binfo));
9871           vcall_offset = fold_build1_loc (input_location,
9872                                       NOP_EXPR, vtable_entry_type,
9873                                       vcall_offset);
9874         }
9875       /* Add the initializer to the vtable.  */
9876       CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, vcall_offset);
9877     }
9878 }
9879
9880 /* Return vtbl initializers for the RTTI entries corresponding to the
9881    BINFO's vtable.  The RTTI entries should indicate the object given
9882    by VID->rtti_binfo.  */
9883
9884 static void
9885 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
9886 {
9887   tree b;
9888   tree t;
9889   tree offset;
9890   tree decl;
9891   tree init;
9892
9893   t = BINFO_TYPE (vid->rtti_binfo);
9894
9895   /* To find the complete object, we will first convert to our most
9896      primary base, and then add the offset in the vtbl to that value.  */
9897   b = most_primary_binfo (binfo);
9898   offset = size_diffop_loc (input_location,
9899                         BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
9900
9901   /* The second entry is the address of the typeinfo object.  */
9902   if (flag_rtti)
9903     decl = build_address (get_tinfo_decl (t));
9904   else
9905     decl = integer_zero_node;
9906
9907   /* Convert the declaration to a type that can be stored in the
9908      vtable.  */
9909   init = build_nop (vfunc_ptr_type_node, decl);
9910   CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
9911
9912   /* Add the offset-to-top entry.  It comes earlier in the vtable than
9913      the typeinfo entry.  Convert the offset to look like a
9914      function pointer, so that we can put it in the vtable.  */
9915   init = build_nop (vfunc_ptr_type_node, offset);
9916   CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
9917 }
9918
9919 /* TRUE iff TYPE is uniquely derived from PARENT.  Ignores
9920    accessibility.  */
9921
9922 bool
9923 uniquely_derived_from_p (tree parent, tree type)
9924 {
9925   tree base = lookup_base (type, parent, ba_unique, NULL, tf_none);
9926   return base && base != error_mark_node;
9927 }
9928
9929 /* TRUE iff TYPE is publicly & uniquely derived from PARENT.  */
9930
9931 bool
9932 publicly_uniquely_derived_p (tree parent, tree type)
9933 {
9934   tree base = lookup_base (type, parent, ba_ignore_scope | ba_check,
9935                            NULL, tf_none);
9936   return base && base != error_mark_node;
9937 }
9938
9939 /* CTX1 and CTX2 are declaration contexts.  Return the innermost common
9940    class between them, if any.  */
9941
9942 tree
9943 common_enclosing_class (tree ctx1, tree ctx2)
9944 {
9945   if (!TYPE_P (ctx1) || !TYPE_P (ctx2))
9946     return NULL_TREE;
9947   gcc_assert (ctx1 == TYPE_MAIN_VARIANT (ctx1)
9948               && ctx2 == TYPE_MAIN_VARIANT (ctx2));
9949   if (ctx1 == ctx2)
9950     return ctx1;
9951   for (tree t = ctx1; TYPE_P (t); t = TYPE_CONTEXT (t))
9952     TYPE_MARKED_P (t) = true;
9953   tree found = NULL_TREE;
9954   for (tree t = ctx2; TYPE_P (t); t = TYPE_CONTEXT (t))
9955     if (TYPE_MARKED_P (t))
9956       {
9957         found = t;
9958         break;
9959       }
9960   for (tree t = ctx1; TYPE_P (t); t = TYPE_CONTEXT (t))
9961     TYPE_MARKED_P (t) = false;
9962   return found;
9963 }
9964
9965 #include "gt-cp-class.h"