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