gcc/cp/class.c

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