gcc/cp/class.c

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