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   /* Let the back end lay out the type.  */
5220   finish_record_layout (rli, /*free_p=*/true);
5221
5222   /* Warn about bases that can't be talked about due to ambiguity.  */
5223   warn_about_ambiguous_bases (t);
5224
5225   /* Now that we're done with layout, give the base fields the real types.  */
5226   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
5227     if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
5228       TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
5229
5230   /* Clean up.  */
5231   splay_tree_delete (empty_base_offsets);
5232
5233   if (CLASSTYPE_EMPTY_P (t)
5234       && tree_int_cst_lt (sizeof_biggest_empty_class,
5235                           TYPE_SIZE_UNIT (t)))
5236     sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
5237 }
5238
5239 /* Determine the "key method" for the class type indicated by TYPE,
5240    and set CLASSTYPE_KEY_METHOD accordingly.  */
5241
5242 void
5243 determine_key_method (tree type)
5244 {
5245   tree method;
5246
5247   if (TYPE_FOR_JAVA (type)
5248       || processing_template_decl
5249       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
5250       || CLASSTYPE_INTERFACE_KNOWN (type))
5251     return;
5252
5253   /* The key method is the first non-pure virtual function that is not
5254      inline at the point of class definition.  On some targets the
5255      key function may not be inline; those targets should not call
5256      this function until the end of the translation unit.  */
5257   for (method = TYPE_METHODS (type); method != NULL_TREE;
5258        method = TREE_CHAIN (method))
5259     if (DECL_VINDEX (method) != NULL_TREE
5260         && ! DECL_DECLARED_INLINE_P (method)
5261         && ! DECL_PURE_VIRTUAL_P (method))
5262       {
5263         CLASSTYPE_KEY_METHOD (type) = method;
5264         break;
5265       }
5266
5267   return;
5268 }
5269
5270 /* Perform processing required when the definition of T (a class type)
5271    is complete.  */
5272
5273 void
5274 finish_struct_1 (tree t)
5275 {
5276   tree x;
5277   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
5278   tree virtuals = NULL_TREE;
5279   int n_fields = 0;
5280
5281   if (COMPLETE_TYPE_P (t))
5282     {
5283       gcc_assert (MAYBE_CLASS_TYPE_P (t));
5284       error ("redefinition of %q#T", t);
5285       popclass ();
5286       return;
5287     }
5288
5289   /* If this type was previously laid out as a forward reference,
5290      make sure we lay it out again.  */
5291   TYPE_SIZE (t) = NULL_TREE;
5292   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5293
5294   /* Make assumptions about the class; we'll reset the flags if
5295      necessary.  */
5296   CLASSTYPE_EMPTY_P (t) = 1;
5297   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5298   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5299
5300   /* Do end-of-class semantic processing: checking the validity of the
5301      bases and members and add implicitly generated methods.  */
5302   check_bases_and_members (t);
5303
5304   /* Find the key method.  */
5305   if (TYPE_CONTAINS_VPTR_P (t))
5306     {
5307       /* The Itanium C++ ABI permits the key method to be chosen when
5308          the class is defined -- even though the key method so
5309          selected may later turn out to be an inline function.  On
5310          some systems (such as ARM Symbian OS) the key method cannot
5311          be determined until the end of the translation unit.  On such
5312          systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
5313          will cause the class to be added to KEYED_CLASSES.  Then, in
5314          finish_file we will determine the key method.  */
5315       if (targetm.cxx.key_method_may_be_inline ())
5316         determine_key_method (t);
5317
5318       /* If a polymorphic class has no key method, we may emit the vtable
5319          in every translation unit where the class definition appears.  */
5320       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5321         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5322     }
5323
5324   /* Layout the class itself.  */
5325   layout_class_type (t, &virtuals);
5326   if (CLASSTYPE_AS_BASE (t) != t)
5327     /* We use the base type for trivial assignments, and hence it
5328        needs a mode.  */
5329     compute_record_mode (CLASSTYPE_AS_BASE (t));
5330
5331   virtuals = modify_all_vtables (t, nreverse (virtuals));
5332
5333   /* If necessary, create the primary vtable for this class.  */
5334   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5335     {
5336       /* We must enter these virtuals into the table.  */
5337       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5338         build_primary_vtable (NULL_TREE, t);
5339       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5340         /* Here we know enough to change the type of our virtual
5341            function table, but we will wait until later this function.  */
5342         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5343     }
5344
5345   if (TYPE_CONTAINS_VPTR_P (t))
5346     {
5347       int vindex;
5348       tree fn;
5349
5350       if (BINFO_VTABLE (TYPE_BINFO (t)))
5351         gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
5352       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5353         gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
5354
5355       /* Add entries for virtual functions introduced by this class.  */
5356       BINFO_VIRTUALS (TYPE_BINFO (t))
5357         = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
5358
5359       /* Set DECL_VINDEX for all functions declared in this class.  */
5360       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5361            fn;
5362            fn = TREE_CHAIN (fn),
5363              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5364                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5365         {
5366           tree fndecl = BV_FN (fn);
5367
5368           if (DECL_THUNK_P (fndecl))
5369             /* A thunk. We should never be calling this entry directly
5370                from this vtable -- we'd use the entry for the non
5371                thunk base function.  */
5372             DECL_VINDEX (fndecl) = NULL_TREE;
5373           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5374             DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
5375         }
5376     }
5377
5378   finish_struct_bits (t);
5379
5380   /* Complete the rtl for any static member objects of the type we're
5381      working on.  */
5382   for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5383     if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5384         && TREE_TYPE (x) != error_mark_node
5385         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5386       DECL_MODE (x) = TYPE_MODE (t);
5387
5388   /* Done with FIELDS...now decide whether to sort these for
5389      faster lookups later.
5390
5391      We use a small number because most searches fail (succeeding
5392      ultimately as the search bores through the inheritance
5393      hierarchy), and we want this failure to occur quickly.  */
5394
5395   n_fields = count_fields (TYPE_FIELDS (t));
5396   if (n_fields > 7)
5397     {
5398       struct sorted_fields_type *field_vec = GGC_NEWVAR
5399          (struct sorted_fields_type,
5400           sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
5401       field_vec->len = n_fields;
5402       add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5403       qsort (field_vec->elts, n_fields, sizeof (tree),
5404              field_decl_cmp);
5405       CLASSTYPE_SORTED_FIELDS (t) = field_vec;
5406     }
5407
5408   /* Complain if one of the field types requires lower visibility.  */
5409   constrain_class_visibility (t);
5410
5411   /* Make the rtl for any new vtables we have created, and unmark
5412      the base types we marked.  */
5413   finish_vtbls (t);
5414
5415   /* Build the VTT for T.  */
5416   build_vtt (t);
5417
5418   /* This warning does not make sense for Java classes, since they
5419      cannot have destructors.  */
5420   if (!TYPE_FOR_JAVA (t) && warn_nonvdtor && TYPE_POLYMORPHIC_P (t))
5421     {
5422       tree dtor;
5423
5424       dtor = CLASSTYPE_DESTRUCTORS (t);
5425       if (/* An implicitly declared destructor is always public.  And,
5426              if it were virtual, we would have created it by now.  */
5427           !dtor
5428           || (!DECL_VINDEX (dtor)
5429               && (/* public non-virtual */
5430                   (!TREE_PRIVATE (dtor) && !TREE_PROTECTED (dtor))
5431                    || (/* non-public non-virtual with friends */
5432                        (TREE_PRIVATE (dtor) || TREE_PROTECTED (dtor))
5433                         && (CLASSTYPE_FRIEND_CLASSES (t)
5434                         || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))))))
5435         warning (OPT_Wnon_virtual_dtor,
5436                  "%q#T has virtual functions and accessible"
5437                  " non-virtual destructor", t);
5438     }
5439
5440   complete_vars (t);
5441
5442   if (warn_overloaded_virtual)
5443     warn_hidden (t);
5444
5445   /* Class layout, assignment of virtual table slots, etc., is now
5446      complete.  Give the back end a chance to tweak the visibility of
5447      the class or perform any other required target modifications.  */
5448   targetm.cxx.adjust_class_at_definition (t);
5449
5450   maybe_suppress_debug_info (t);
5451
5452   dump_class_hierarchy (t);
5453
5454   /* Finish debugging output for this type.  */
5455   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5456 }
5457
5458 /* When T was built up, the member declarations were added in reverse
5459    order.  Rearrange them to declaration order.  */
5460
5461 void
5462 unreverse_member_declarations (tree t)
5463 {
5464   tree next;
5465   tree prev;
5466   tree x;
5467
5468   /* The following lists are all in reverse order.  Put them in
5469      declaration order now.  */
5470   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5471   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5472
5473   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5474      reverse order, so we can't just use nreverse.  */
5475   prev = NULL_TREE;
5476   for (x = TYPE_FIELDS (t);
5477        x && TREE_CODE (x) != TYPE_DECL;
5478        x = next)
5479     {
5480       next = TREE_CHAIN (x);
5481       TREE_CHAIN (x) = prev;
5482       prev = x;
5483     }
5484   if (prev)
5485     {
5486       TREE_CHAIN (TYPE_FIELDS (t)) = x;
5487       if (prev)
5488         TYPE_FIELDS (t) = prev;
5489     }
5490 }
5491
5492 tree
5493 finish_struct (tree t, tree attributes)
5494 {
5495   location_t saved_loc = input_location;
5496
5497   /* Now that we've got all the field declarations, reverse everything
5498      as necessary.  */
5499   unreverse_member_declarations (t);
5500
5501   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5502
5503   /* Nadger the current location so that diagnostics point to the start of
5504      the struct, not the end.  */
5505   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5506
5507   if (processing_template_decl)
5508     {
5509       tree x;
5510
5511       finish_struct_methods (t);
5512       TYPE_SIZE (t) = bitsize_zero_node;
5513       TYPE_SIZE_UNIT (t) = size_zero_node;
5514
5515       /* We need to emit an error message if this type was used as a parameter
5516          and it is an abstract type, even if it is a template. We construct
5517          a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5518          account and we call complete_vars with this type, which will check
5519          the PARM_DECLS. Note that while the type is being defined,
5520          CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5521          (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it.  */
5522       CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5523       for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
5524         if (DECL_PURE_VIRTUAL_P (x))
5525           VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
5526       complete_vars (t);
5527
5528       /* Remember current #pragma pack value.  */
5529       TYPE_PRECISION (t) = maximum_field_alignment;
5530     }
5531   else
5532     finish_struct_1 (t);
5533
5534   input_location = saved_loc;
5535
5536   TYPE_BEING_DEFINED (t) = 0;
5537
5538   if (current_class_type)
5539     popclass ();
5540   else
5541     error ("trying to finish struct, but kicked out due to previous parse errors");
5542
5543   if (processing_template_decl && at_function_scope_p ())
5544     add_stmt (build_min (TAG_DEFN, t));
5545
5546   return t;
5547 }
5548 \f
5549 /* Return the dynamic type of INSTANCE, if known.
5550    Used to determine whether the virtual function table is needed
5551    or not.
5552
5553    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5554    of our knowledge of its type.  *NONNULL should be initialized
5555    before this function is called.  */
5556
5557 static tree
5558 fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
5559 {
5560 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
5561
5562   switch (TREE_CODE (instance))
5563     {
5564     case INDIRECT_REF:
5565       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5566         return NULL_TREE;
5567       else
5568         return RECUR (TREE_OPERAND (instance, 0));
5569
5570     case CALL_EXPR:
5571       /* This is a call to a constructor, hence it's never zero.  */
5572       if (TREE_HAS_CONSTRUCTOR (instance))
5573         {
5574           if (nonnull)
5575             *nonnull = 1;
5576           return TREE_TYPE (instance);
5577         }
5578       return NULL_TREE;
5579
5580     case SAVE_EXPR:
5581       /* This is a call to a constructor, hence it's never zero.  */
5582       if (TREE_HAS_CONSTRUCTOR (instance))
5583         {
5584           if (nonnull)
5585             *nonnull = 1;
5586           return TREE_TYPE (instance);
5587         }
5588       return RECUR (TREE_OPERAND (instance, 0));
5589
5590     case POINTER_PLUS_EXPR:
5591     case PLUS_EXPR:
5592     case MINUS_EXPR:
5593       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5594         return RECUR (TREE_OPERAND (instance, 0));
5595       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5596         /* Propagate nonnull.  */
5597         return RECUR (TREE_OPERAND (instance, 0));
5598
5599       return NULL_TREE;
5600
5601     CASE_CONVERT:
5602       return RECUR (TREE_OPERAND (instance, 0));
5603
5604     case ADDR_EXPR:
5605       instance = TREE_OPERAND (instance, 0);
5606       if (nonnull)
5607         {
5608           /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5609              with a real object -- given &p->f, p can still be null.  */
5610           tree t = get_base_address (instance);
5611           /* ??? Probably should check DECL_WEAK here.  */
5612           if (t && DECL_P (t))
5613             *nonnull = 1;
5614         }
5615       return RECUR (instance);
5616
5617     case COMPONENT_REF:
5618       /* If this component is really a base class reference, then the field
5619          itself isn't definitive.  */
5620       if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5621         return RECUR (TREE_OPERAND (instance, 0));
5622       return RECUR (TREE_OPERAND (instance, 1));
5623
5624     case VAR_DECL:
5625     case FIELD_DECL:
5626       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5627           && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance))))
5628         {
5629           if (nonnull)
5630             *nonnull = 1;
5631           return TREE_TYPE (TREE_TYPE (instance));
5632         }
5633       /* fall through...  */
5634     case TARGET_EXPR:
5635     case PARM_DECL:
5636     case RESULT_DECL:
5637       if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance)))
5638         {
5639           if (nonnull)
5640             *nonnull = 1;
5641           return TREE_TYPE (instance);
5642         }
5643       else if (instance == current_class_ptr)
5644         {
5645           if (nonnull)
5646             *nonnull = 1;
5647
5648           /* if we're in a ctor or dtor, we know our type.  */
5649           if (DECL_LANG_SPECIFIC (current_function_decl)
5650               && (DECL_CONSTRUCTOR_P (current_function_decl)
5651                   || DECL_DESTRUCTOR_P (current_function_decl)))
5652             {
5653               if (cdtorp)
5654                 *cdtorp = 1;
5655               return TREE_TYPE (TREE_TYPE (instance));
5656             }
5657         }
5658       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5659         {
5660           /* We only need one hash table because it is always left empty.  */
5661           static htab_t ht;
5662           if (!ht)
5663             ht = htab_create (37,
5664                               htab_hash_pointer,
5665                               htab_eq_pointer,
5666                               /*htab_del=*/NULL);
5667
5668           /* Reference variables should be references to objects.  */
5669           if (nonnull)
5670             *nonnull = 1;
5671
5672           /* Enter the INSTANCE in a table to prevent recursion; a
5673              variable's initializer may refer to the variable
5674              itself.  */
5675           if (TREE_CODE (instance) == VAR_DECL
5676               && DECL_INITIAL (instance)
5677               && !htab_find (ht, instance))
5678             {
5679               tree type;
5680               void **slot;
5681
5682               slot = htab_find_slot (ht, instance, INSERT);
5683               *slot = instance;
5684               type = RECUR (DECL_INITIAL (instance));
5685               htab_remove_elt (ht, instance);
5686
5687               return type;
5688             }
5689         }
5690       return NULL_TREE;
5691
5692     default:
5693       return NULL_TREE;
5694     }
5695 #undef RECUR
5696 }
5697
5698 /* Return nonzero if the dynamic type of INSTANCE is known, and
5699    equivalent to the static type.  We also handle the case where
5700    INSTANCE is really a pointer. Return negative if this is a
5701    ctor/dtor. There the dynamic type is known, but this might not be
5702    the most derived base of the original object, and hence virtual
5703    bases may not be layed out according to this type.
5704
5705    Used to determine whether the virtual function table is needed
5706    or not.
5707
5708    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5709    of our knowledge of its type.  *NONNULL should be initialized
5710    before this function is called.  */
5711
5712 int
5713 resolves_to_fixed_type_p (tree instance, int* nonnull)
5714 {
5715   tree t = TREE_TYPE (instance);
5716   int cdtorp = 0;
5717   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5718   if (fixed == NULL_TREE)
5719     return 0;
5720   if (POINTER_TYPE_P (t))
5721     t = TREE_TYPE (t);
5722   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5723     return 0;
5724   return cdtorp ? -1 : 1;
5725 }
5726
5727 \f
5728 void
5729 init_class_processing (void)
5730 {
5731   current_class_depth = 0;
5732   current_class_stack_size = 10;
5733   current_class_stack
5734     = XNEWVEC (struct class_stack_node, current_class_stack_size);
5735   local_classes = VEC_alloc (tree, gc, 8);
5736   sizeof_biggest_empty_class = size_zero_node;
5737
5738   ridpointers[(int) RID_PUBLIC] = access_public_node;
5739   ridpointers[(int) RID_PRIVATE] = access_private_node;
5740   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5741 }
5742
5743 /* Restore the cached PREVIOUS_CLASS_LEVEL.  */
5744
5745 static void
5746 restore_class_cache (void)
5747 {
5748   tree type;
5749
5750   /* We are re-entering the same class we just left, so we don't
5751      have to search the whole inheritance matrix to find all the
5752      decls to bind again.  Instead, we install the cached
5753      class_shadowed list and walk through it binding names.  */
5754   push_binding_level (previous_class_level);
5755   class_binding_level = previous_class_level;
5756   /* Restore IDENTIFIER_TYPE_VALUE.  */
5757   for (type = class_binding_level->type_shadowed;
5758        type;
5759        type = TREE_CHAIN (type))
5760     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5761 }
5762
5763 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5764    appropriate for TYPE.
5765
5766    So that we may avoid calls to lookup_name, we cache the _TYPE
5767    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5768
5769    For multiple inheritance, we perform a two-pass depth-first search
5770    of the type lattice.  */
5771
5772 void
5773 pushclass (tree type)
5774 {
5775   class_stack_node_t csn;
5776
5777   type = TYPE_MAIN_VARIANT (type);
5778
5779   /* Make sure there is enough room for the new entry on the stack.  */
5780   if (current_class_depth + 1 >= current_class_stack_size)
5781     {
5782       current_class_stack_size *= 2;
5783       current_class_stack
5784         = XRESIZEVEC (struct class_stack_node, current_class_stack,
5785                       current_class_stack_size);
5786     }
5787
5788   /* Insert a new entry on the class stack.  */
5789   csn = current_class_stack + current_class_depth;
5790   csn->name = current_class_name;
5791   csn->type = current_class_type;
5792   csn->access = current_access_specifier;
5793   csn->names_used = 0;
5794   csn->hidden = 0;
5795   current_class_depth++;
5796
5797   /* Now set up the new type.  */
5798   current_class_name = TYPE_NAME (type);
5799   if (TREE_CODE (current_class_name) == TYPE_DECL)
5800     current_class_name = DECL_NAME (current_class_name);
5801   current_class_type = type;
5802
5803   /* By default, things in classes are private, while things in
5804      structures or unions are public.  */
5805   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5806                               ? access_private_node
5807                               : access_public_node);
5808
5809   if (previous_class_level
5810       && type != previous_class_level->this_entity
5811       && current_class_depth == 1)
5812     {
5813       /* Forcibly remove any old class remnants.  */
5814       invalidate_class_lookup_cache ();
5815     }
5816
5817   if (!previous_class_level
5818       || type != previous_class_level->this_entity
5819       || current_class_depth > 1)
5820     pushlevel_class ();
5821   else
5822     restore_class_cache ();
5823 }
5824
5825 /* When we exit a toplevel class scope, we save its binding level so
5826    that we can restore it quickly.  Here, we've entered some other
5827    class, so we must invalidate our cache.  */
5828
5829 void
5830 invalidate_class_lookup_cache (void)
5831 {
5832   previous_class_level = NULL;
5833 }
5834
5835 /* Get out of the current class scope. If we were in a class scope
5836    previously, that is the one popped to.  */
5837
5838 void
5839 popclass (void)
5840 {
5841   poplevel_class ();
5842
5843   current_class_depth--;
5844   current_class_name = current_class_stack[current_class_depth].name;
5845   current_class_type = current_class_stack[current_class_depth].type;
5846   current_access_specifier = current_class_stack[current_class_depth].access;
5847   if (current_class_stack[current_class_depth].names_used)
5848     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5849 }
5850
5851 /* Mark the top of the class stack as hidden.  */
5852
5853 void
5854 push_class_stack (void)
5855 {
5856   if (current_class_depth)
5857     ++current_class_stack[current_class_depth - 1].hidden;
5858 }
5859
5860 /* Mark the top of the class stack as un-hidden.  */
5861
5862 void
5863 pop_class_stack (void)
5864 {
5865   if (current_class_depth)
5866     --current_class_stack[current_class_depth - 1].hidden;
5867 }
5868
5869 /* Returns 1 if the class type currently being defined is either T or
5870    a nested type of T.  */
5871
5872 bool
5873 currently_open_class (tree t)
5874 {
5875   int i;
5876
5877   if (!CLASS_TYPE_P (t))
5878     return false;
5879
5880   t = TYPE_MAIN_VARIANT (t);
5881
5882   /* We start looking from 1 because entry 0 is from global scope,
5883      and has no type.  */
5884   for (i = current_class_depth; i > 0; --i)
5885     {
5886       tree c;
5887       if (i == current_class_depth)
5888         c = current_class_type;
5889       else
5890         {
5891           if (current_class_stack[i].hidden)
5892             break;
5893           c = current_class_stack[i].type;
5894         }
5895       if (!c)
5896         continue;
5897       if (same_type_p (c, t))
5898         return true;
5899     }
5900   return false;
5901 }
5902
5903 /* If either current_class_type or one of its enclosing classes are derived
5904    from T, return the appropriate type.  Used to determine how we found
5905    something via unqualified lookup.  */
5906
5907 tree
5908 currently_open_derived_class (tree t)
5909 {
5910   int i;
5911
5912   /* The bases of a dependent type are unknown.  */
5913   if (dependent_type_p (t))
5914     return NULL_TREE;
5915
5916   if (!current_class_type)
5917     return NULL_TREE;
5918
5919   if (DERIVED_FROM_P (t, current_class_type))
5920     return current_class_type;
5921
5922   for (i = current_class_depth - 1; i > 0; --i)
5923     {
5924       if (current_class_stack[i].hidden)
5925         break;
5926       if (DERIVED_FROM_P (t, current_class_stack[i].type))
5927         return current_class_stack[i].type;
5928     }
5929
5930   return NULL_TREE;
5931 }
5932
5933 /* When entering a class scope, all enclosing class scopes' names with
5934    static meaning (static variables, static functions, types and
5935    enumerators) have to be visible.  This recursive function calls
5936    pushclass for all enclosing class contexts until global or a local
5937    scope is reached.  TYPE is the enclosed class.  */
5938
5939 void
5940 push_nested_class (tree type)
5941 {
5942   /* A namespace might be passed in error cases, like A::B:C.  */
5943   if (type == NULL_TREE
5944       || !CLASS_TYPE_P (type))
5945     return;
5946
5947   push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type)));
5948
5949   pushclass (type);
5950 }
5951
5952 /* Undoes a push_nested_class call.  */
5953
5954 void
5955 pop_nested_class (void)
5956 {
5957   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5958
5959   popclass ();
5960   if (context && CLASS_TYPE_P (context))
5961     pop_nested_class ();
5962 }
5963
5964 /* Returns the number of extern "LANG" blocks we are nested within.  */
5965
5966 int
5967 current_lang_depth (void)
5968 {
5969   return VEC_length (tree, current_lang_base);
5970 }
5971
5972 /* Set global variables CURRENT_LANG_NAME to appropriate value
5973    so that behavior of name-mangling machinery is correct.  */
5974
5975 void
5976 push_lang_context (tree name)
5977 {
5978   VEC_safe_push (tree, gc, current_lang_base, current_lang_name);
5979
5980   if (name == lang_name_cplusplus)
5981     {
5982       current_lang_name = name;
5983     }
5984   else if (name == lang_name_java)
5985     {
5986       current_lang_name = name;
5987       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5988          (See record_builtin_java_type in decl.c.)  However, that causes
5989          incorrect debug entries if these types are actually used.
5990          So we re-enable debug output after extern "Java".  */
5991       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5992       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5993       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5994       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5995       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5996       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5997       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5998       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5999     }
6000   else if (name == lang_name_c)
6001     {
6002       current_lang_name = name;
6003     }
6004   else
6005     error ("language string %<\"%E\"%> not recognized", name);
6006 }
6007
6008 /* Get out of the current language scope.  */
6009
6010 void
6011 pop_lang_context (void)
6012 {
6013   current_lang_name = VEC_pop (tree, current_lang_base);
6014 }
6015 \f
6016 /* Type instantiation routines.  */
6017
6018 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6019    matches the TARGET_TYPE.  If there is no satisfactory match, return
6020    error_mark_node, and issue an error & warning messages under
6021    control of FLAGS.  Permit pointers to member function if FLAGS
6022    permits.  If TEMPLATE_ONLY, the name of the overloaded function was
6023    a template-id, and EXPLICIT_TARGS are the explicitly provided
6024    template arguments.
6025
6026    If OVERLOAD is for one or more member functions, then ACCESS_PATH
6027    is the base path used to reference those member functions.  If
6028    TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
6029    resolved to a member function, access checks will be performed and
6030    errors issued if appropriate.  */
6031
6032 static tree
6033 resolve_address_of_overloaded_function (tree target_type,
6034                                         tree overload,
6035                                         tsubst_flags_t flags,
6036                                         bool template_only,
6037                                         tree explicit_targs,
6038                                         tree access_path)
6039 {
6040   /* Here's what the standard says:
6041
6042        [over.over]
6043
6044        If the name is a function template, template argument deduction
6045        is done, and if the argument deduction succeeds, the deduced
6046        arguments are used to generate a single template function, which
6047        is added to the set of overloaded functions considered.
6048
6049        Non-member functions and static member functions match targets of
6050        type "pointer-to-function" or "reference-to-function."  Nonstatic
6051        member functions match targets of type "pointer-to-member
6052        function;" the function type of the pointer to member is used to
6053        select the member function from the set of overloaded member
6054        functions.  If a nonstatic member function is selected, the
6055        reference to the overloaded function name is required to have the
6056        form of a pointer to member as described in 5.3.1.
6057
6058        If more than one function is selected, any template functions in
6059        the set are eliminated if the set also contains a non-template
6060        function, and any given template function is eliminated if the
6061        set contains a second template function that is more specialized
6062        than the first according to the partial ordering rules 14.5.5.2.
6063        After such eliminations, if any, there shall remain exactly one
6064        selected function.  */
6065
6066   int is_ptrmem = 0;
6067   /* We store the matches in a TREE_LIST rooted here.  The functions
6068      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6069      interoperability with most_specialized_instantiation.  */
6070   tree matches = NULL_TREE;
6071   tree fn;
6072   tree target_fn_type;
6073
6074   /* By the time we get here, we should be seeing only real
6075      pointer-to-member types, not the internal POINTER_TYPE to
6076      METHOD_TYPE representation.  */
6077   gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
6078               || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
6079
6080   gcc_assert (is_overloaded_fn (overload));
6081
6082   /* Check that the TARGET_TYPE is reasonable.  */
6083   if (TYPE_PTRFN_P (target_type))
6084     /* This is OK.  */;
6085   else if (TYPE_PTRMEMFUNC_P (target_type))
6086     /* This is OK, too.  */
6087     is_ptrmem = 1;
6088   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
6089     /* This is OK, too.  This comes from a conversion to reference
6090        type.  */
6091     target_type = build_reference_type (target_type);
6092   else
6093     {
6094       if (flags & tf_error)
6095         error ("cannot resolve overloaded function %qD based on"
6096                " conversion to type %qT",
6097                DECL_NAME (OVL_FUNCTION (overload)), target_type);
6098       return error_mark_node;
6099     }
6100
6101   /* Non-member functions and static member functions match targets of type
6102      "pointer-to-function" or "reference-to-function."  Nonstatic member
6103      functions match targets of type "pointer-to-member-function;" the
6104      function type of the pointer to member is used to select the member
6105      function from the set of overloaded member functions.
6106
6107      So figure out the FUNCTION_TYPE that we want to match against.  */
6108   target_fn_type = static_fn_type (target_type);
6109
6110   /* If we can find a non-template function that matches, we can just
6111      use it.  There's no point in generating template instantiations
6112      if we're just going to throw them out anyhow.  But, of course, we
6113      can only do this when we don't *need* a template function.  */
6114   if (!template_only)
6115     {
6116       tree fns;
6117
6118       for (fns = overload; fns; fns = OVL_NEXT (fns))
6119         {
6120           tree fn = OVL_CURRENT (fns);
6121
6122           if (TREE_CODE (fn) == TEMPLATE_DECL)
6123             /* We're not looking for templates just yet.  */
6124             continue;
6125
6126           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6127               != is_ptrmem)
6128             /* We're looking for a non-static member, and this isn't
6129                one, or vice versa.  */
6130             continue;
6131
6132           /* Ignore functions which haven't been explicitly
6133              declared.  */
6134           if (DECL_ANTICIPATED (fn))
6135             continue;
6136
6137           /* See if there's a match.  */
6138           if (same_type_p (target_fn_type, static_fn_type (fn)))
6139             matches = tree_cons (fn, NULL_TREE, matches);
6140         }
6141     }
6142
6143   /* Now, if we've already got a match (or matches), there's no need
6144      to proceed to the template functions.  But, if we don't have a
6145      match we need to look at them, too.  */
6146   if (!matches)
6147     {
6148       tree target_arg_types;
6149       tree target_ret_type;
6150       tree fns;
6151       tree *args;
6152       unsigned int nargs, ia;
6153       tree arg;
6154
6155       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
6156       target_ret_type = TREE_TYPE (target_fn_type);
6157
6158       nargs = list_length (target_arg_types);
6159       args = XALLOCAVEC (tree, nargs);
6160       for (arg = target_arg_types, ia = 0;
6161            arg != NULL_TREE && arg != void_list_node;
6162            arg = TREE_CHAIN (arg), ++ia)
6163         args[ia] = TREE_VALUE (arg);
6164       nargs = ia;
6165
6166       for (fns = overload; fns; fns = OVL_NEXT (fns))
6167         {
6168           tree fn = OVL_CURRENT (fns);
6169           tree instantiation;
6170           tree targs;
6171
6172           if (TREE_CODE (fn) != TEMPLATE_DECL)
6173             /* We're only looking for templates.  */
6174             continue;
6175
6176           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6177               != is_ptrmem)
6178             /* We're not looking for a non-static member, and this is
6179                one, or vice versa.  */
6180             continue;
6181
6182           /* Try to do argument deduction.  */
6183           targs = make_tree_vec (DECL_NTPARMS (fn));
6184           if (fn_type_unification (fn, explicit_targs, targs, args, nargs,
6185                                    target_ret_type, DEDUCE_EXACT,
6186                                    LOOKUP_NORMAL))
6187             /* Argument deduction failed.  */
6188             continue;
6189
6190           /* Instantiate the template.  */
6191           instantiation = instantiate_template (fn, targs, flags);
6192           if (instantiation == error_mark_node)
6193             /* Instantiation failed.  */
6194             continue;
6195
6196           /* See if there's a match.  */
6197           if (same_type_p (target_fn_type, static_fn_type (instantiation)))
6198             matches = tree_cons (instantiation, fn, matches);
6199         }
6200
6201       /* Now, remove all but the most specialized of the matches.  */
6202       if (matches)
6203         {
6204           tree match = most_specialized_instantiation (matches);
6205
6206           if (match != error_mark_node)
6207             matches = tree_cons (TREE_PURPOSE (match),
6208                                  NULL_TREE,
6209                                  NULL_TREE);
6210         }
6211     }
6212
6213   /* Now we should have exactly one function in MATCHES.  */
6214   if (matches == NULL_TREE)
6215     {
6216       /* There were *no* matches.  */
6217       if (flags & tf_error)
6218         {
6219           error ("no matches converting function %qD to type %q#T",
6220                  DECL_NAME (OVL_CURRENT (overload)),
6221                  target_type);
6222
6223           /* print_candidates expects a chain with the functions in
6224              TREE_VALUE slots, so we cons one up here (we're losing anyway,
6225              so why be clever?).  */
6226           for (; overload; overload = OVL_NEXT (overload))
6227             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
6228                                  matches);
6229
6230           print_candidates (matches);
6231         }
6232       return error_mark_node;
6233     }
6234   else if (TREE_CHAIN (matches))
6235     {
6236       /* There were too many matches.  First check if they're all
6237          the same function.  */
6238       tree match;
6239
6240       fn = TREE_PURPOSE (matches);
6241       for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match))
6242         if (!decls_match (fn, TREE_PURPOSE (match)))
6243           break;
6244
6245       if (match)
6246         {
6247           if (flags & tf_error)
6248             {
6249               error ("converting overloaded function %qD to type %q#T is ambiguous",
6250                      DECL_NAME (OVL_FUNCTION (overload)),
6251                      target_type);
6252
6253               /* Since print_candidates expects the functions in the
6254                  TREE_VALUE slot, we flip them here.  */
6255               for (match = matches; match; match = TREE_CHAIN (match))
6256                 TREE_VALUE (match) = TREE_PURPOSE (match);
6257
6258               print_candidates (matches);
6259             }
6260
6261           return error_mark_node;
6262         }
6263     }
6264
6265   /* Good, exactly one match.  Now, convert it to the correct type.  */
6266   fn = TREE_PURPOSE (matches);
6267
6268   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
6269       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
6270     {
6271       static int explained;
6272
6273       if (!(flags & tf_error))
6274         return error_mark_node;
6275
6276       permerror (input_location, "assuming pointer to member %qD", fn);
6277       if (!explained)
6278         {
6279           inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
6280           explained = 1;
6281         }
6282     }
6283
6284   /* If we're doing overload resolution purely for the purpose of
6285      determining conversion sequences, we should not consider the
6286      function used.  If this conversion sequence is selected, the
6287      function will be marked as used at this point.  */
6288   if (!(flags & tf_conv))
6289     {
6290       /* Make =delete work with SFINAE.  */
6291       if (DECL_DELETED_FN (fn) && !(flags & tf_error))
6292         return error_mark_node;
6293
6294       mark_used (fn);
6295     }
6296
6297   /* We could not check access to member functions when this
6298      expression was originally created since we did not know at that
6299      time to which function the expression referred.  */
6300   if (!(flags & tf_no_access_control)
6301       && DECL_FUNCTION_MEMBER_P (fn))
6302     {
6303       gcc_assert (access_path);
6304       perform_or_defer_access_check (access_path, fn, fn);
6305     }
6306
6307   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
6308     return cp_build_unary_op (ADDR_EXPR, fn, 0, flags);
6309   else
6310     {
6311       /* The target must be a REFERENCE_TYPE.  Above, cp_build_unary_op
6312          will mark the function as addressed, but here we must do it
6313          explicitly.  */
6314       cxx_mark_addressable (fn);
6315
6316       return fn;
6317     }
6318 }
6319
6320 /* This function will instantiate the type of the expression given in
6321    RHS to match the type of LHSTYPE.  If errors exist, then return
6322    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
6323    we complain on errors.  If we are not complaining, never modify rhs,
6324    as overload resolution wants to try many possible instantiations, in
6325    the hope that at least one will work.
6326
6327    For non-recursive calls, LHSTYPE should be a function, pointer to
6328    function, or a pointer to member function.  */
6329
6330 tree
6331 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6332 {
6333   tsubst_flags_t flags_in = flags;
6334   tree access_path = NULL_TREE;
6335
6336   flags &= ~tf_ptrmem_ok;
6337
6338   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
6339     {
6340       if (flags & tf_error)
6341         error ("not enough type information");
6342       return error_mark_node;
6343     }
6344
6345   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6346     {
6347       if (same_type_p (lhstype, TREE_TYPE (rhs)))
6348         return rhs;
6349       if (flag_ms_extensions
6350           && TYPE_PTRMEMFUNC_P (lhstype)
6351           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6352         /* Microsoft allows `A::f' to be resolved to a
6353            pointer-to-member.  */
6354         ;
6355       else
6356         {
6357           if (flags & tf_error)
6358             error ("argument of type %qT does not match %qT",
6359                    TREE_TYPE (rhs), lhstype);
6360           return error_mark_node;
6361         }
6362     }
6363
6364   if (TREE_CODE (rhs) == BASELINK)
6365     {
6366       access_path = BASELINK_ACCESS_BINFO (rhs);
6367       rhs = BASELINK_FUNCTIONS (rhs);
6368     }
6369
6370   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6371      deduce any type information.  */
6372   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6373     {
6374       if (flags & tf_error)
6375         error ("not enough type information");
6376       return error_mark_node;
6377     }
6378
6379   /* There only a few kinds of expressions that may have a type
6380      dependent on overload resolution.  */
6381   gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6382               || TREE_CODE (rhs) == COMPONENT_REF
6383               || really_overloaded_fn (rhs)
6384               || (flag_ms_extensions && TREE_CODE (rhs) == FUNCTION_DECL));
6385
6386   /* This should really only be used when attempting to distinguish
6387      what sort of a pointer to function we have.  For now, any
6388      arithmetic operation which is not supported on pointers
6389      is rejected as an error.  */
6390
6391   switch (TREE_CODE (rhs))
6392     {
6393     case COMPONENT_REF:
6394       {
6395         tree member = TREE_OPERAND (rhs, 1);
6396
6397         member = instantiate_type (lhstype, member, flags);
6398         if (member != error_mark_node
6399             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6400           /* Do not lose object's side effects.  */
6401           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6402                          TREE_OPERAND (rhs, 0), member);
6403         return member;
6404       }
6405
6406     case OFFSET_REF:
6407       rhs = TREE_OPERAND (rhs, 1);
6408       if (BASELINK_P (rhs))
6409         return instantiate_type (lhstype, rhs, flags_in);
6410
6411       /* This can happen if we are forming a pointer-to-member for a
6412          member template.  */
6413       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6414
6415       /* Fall through.  */
6416
6417     case TEMPLATE_ID_EXPR:
6418       {
6419         tree fns = TREE_OPERAND (rhs, 0);
6420         tree args = TREE_OPERAND (rhs, 1);
6421
6422         return
6423           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6424                                                   /*template_only=*/true,
6425                                                   args, access_path);
6426       }
6427
6428     case OVERLOAD:
6429     case FUNCTION_DECL:
6430       return
6431         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6432                                                 /*template_only=*/false,
6433                                                 /*explicit_targs=*/NULL_TREE,
6434                                                 access_path);
6435
6436     case ADDR_EXPR:
6437     {
6438       if (PTRMEM_OK_P (rhs))
6439         flags |= tf_ptrmem_ok;
6440
6441       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6442     }
6443
6444     case ERROR_MARK:
6445       return error_mark_node;
6446
6447     default:
6448       gcc_unreachable ();
6449     }
6450   return error_mark_node;
6451 }
6452 \f
6453 /* Return the name of the virtual function pointer field
6454    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6455    this may have to look back through base types to find the
6456    ultimate field name.  (For single inheritance, these could
6457    all be the same name.  Who knows for multiple inheritance).  */
6458
6459 static tree
6460 get_vfield_name (tree type)
6461 {
6462   tree binfo, base_binfo;
6463   char *buf;
6464
6465   for (binfo = TYPE_BINFO (type);
6466        BINFO_N_BASE_BINFOS (binfo);
6467        binfo = base_binfo)
6468     {
6469       base_binfo = BINFO_BASE_BINFO (binfo, 0);
6470
6471       if (BINFO_VIRTUAL_P (base_binfo)
6472           || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6473         break;
6474     }
6475
6476   type = BINFO_TYPE (binfo);
6477   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6478                          + TYPE_NAME_LENGTH (type) + 2);
6479   sprintf (buf, VFIELD_NAME_FORMAT,
6480            IDENTIFIER_POINTER (constructor_name (type)));
6481   return get_identifier (buf);
6482 }
6483
6484 void
6485 print_class_statistics (void)
6486 {
6487 #ifdef GATHER_STATISTICS
6488   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6489   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6490   if (n_vtables)
6491     {
6492       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6493                n_vtables, n_vtable_searches);
6494       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6495                n_vtable_entries, n_vtable_elems);
6496     }
6497 #endif
6498 }
6499
6500 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6501    according to [class]:
6502                                           The class-name is also inserted
6503    into  the scope of the class itself.  For purposes of access checking,
6504    the inserted class name is treated as if it were a public member name.  */
6505
6506 void
6507 build_self_reference (void)
6508 {
6509   tree name = constructor_name (current_class_type);
6510   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6511   tree saved_cas;
6512
6513   DECL_NONLOCAL (value) = 1;
6514   DECL_CONTEXT (value) = current_class_type;
6515   DECL_ARTIFICIAL (value) = 1;
6516   SET_DECL_SELF_REFERENCE_P (value);
6517   cp_set_underlying_type (value);
6518
6519   if (processing_template_decl)
6520     value = push_template_decl (value);
6521
6522   saved_cas = current_access_specifier;
6523   current_access_specifier = access_public_node;
6524   finish_member_declaration (value);
6525   current_access_specifier = saved_cas;
6526 }
6527
6528 /* Returns 1 if TYPE contains only padding bytes.  */
6529
6530 int
6531 is_empty_class (tree type)
6532 {
6533   if (type == error_mark_node)
6534     return 0;
6535
6536   if (! CLASS_TYPE_P (type))
6537     return 0;
6538
6539   /* In G++ 3.2, whether or not a class was empty was determined by
6540      looking at its size.  */
6541   if (abi_version_at_least (2))
6542     return CLASSTYPE_EMPTY_P (type);
6543   else
6544     return integer_zerop (CLASSTYPE_SIZE (type));
6545 }
6546
6547 /* Returns true if TYPE contains an empty class.  */
6548
6549 static bool
6550 contains_empty_class_p (tree type)
6551 {
6552   if (is_empty_class (type))
6553     return true;
6554   if (CLASS_TYPE_P (type))
6555     {
6556       tree field;
6557       tree binfo;
6558       tree base_binfo;
6559       int i;
6560
6561       for (binfo = TYPE_BINFO (type), i = 0;
6562            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6563         if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6564           return true;
6565       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6566         if (TREE_CODE (field) == FIELD_DECL
6567             && !DECL_ARTIFICIAL (field)
6568             && is_empty_class (TREE_TYPE (field)))
6569           return true;
6570     }
6571   else if (TREE_CODE (type) == ARRAY_TYPE)
6572     return contains_empty_class_p (TREE_TYPE (type));
6573   return false;
6574 }
6575
6576 /* Returns true if TYPE contains no actual data, just various
6577    possible combinations of empty classes.  */
6578
6579 bool
6580 is_really_empty_class (tree type)
6581 {
6582   if (is_empty_class (type))
6583     return true;
6584   if (CLASS_TYPE_P (type))
6585     {
6586       tree field;
6587       tree binfo;
6588       tree base_binfo;
6589       int i;
6590
6591       for (binfo = TYPE_BINFO (type), i = 0;
6592            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6593         if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
6594           return false;
6595       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6596         if (TREE_CODE (field) == FIELD_DECL
6597             && !DECL_ARTIFICIAL (field)
6598             && !is_really_empty_class (TREE_TYPE (field)))
6599           return false;
6600       return true;
6601     }
6602   else if (TREE_CODE (type) == ARRAY_TYPE)
6603     return is_really_empty_class (TREE_TYPE (type));
6604   return false;
6605 }
6606
6607 /* Note that NAME was looked up while the current class was being
6608    defined and that the result of that lookup was DECL.  */
6609
6610 void
6611 maybe_note_name_used_in_class (tree name, tree decl)
6612 {
6613   splay_tree names_used;
6614
6615   /* If we're not defining a class, there's nothing to do.  */
6616   if (!(innermost_scope_kind() == sk_class
6617         && TYPE_BEING_DEFINED (current_class_type)
6618         && !LAMBDA_TYPE_P (current_class_type)))
6619     return;
6620
6621   /* If there's already a binding for this NAME, then we don't have
6622      anything to worry about.  */
6623   if (lookup_member (current_class_type, name,
6624                      /*protect=*/0, /*want_type=*/false))
6625     return;
6626
6627   if (!current_class_stack[current_class_depth - 1].names_used)
6628     current_class_stack[current_class_depth - 1].names_used
6629       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6630   names_used = current_class_stack[current_class_depth - 1].names_used;
6631
6632   splay_tree_insert (names_used,
6633                      (splay_tree_key) name,
6634                      (splay_tree_value) decl);
6635 }
6636
6637 /* Note that NAME was declared (as DECL) in the current class.  Check
6638    to see that the declaration is valid.  */
6639
6640 void
6641 note_name_declared_in_class (tree name, tree decl)
6642 {
6643   splay_tree names_used;
6644   splay_tree_node n;
6645
6646   /* Look to see if we ever used this name.  */
6647   names_used
6648     = current_class_stack[current_class_depth - 1].names_used;
6649   if (!names_used)
6650     return;
6651
6652   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6653   if (n)
6654     {
6655       /* [basic.scope.class]
6656
6657          A name N used in a class S shall refer to the same declaration
6658          in its context and when re-evaluated in the completed scope of
6659          S.  */
6660       permerror (input_location, "declaration of %q#D", decl);
6661       permerror (input_location, "changes meaning of %qD from %q+#D",
6662                DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
6663     }
6664 }
6665
6666 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6667    Secondary vtables are merged with primary vtables; this function
6668    will return the VAR_DECL for the primary vtable.  */
6669
6670 tree
6671 get_vtbl_decl_for_binfo (tree binfo)
6672 {
6673   tree decl;
6674
6675   decl = BINFO_VTABLE (binfo);
6676   if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR)
6677     {
6678       gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6679       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6680     }
6681   if (decl)
6682     gcc_assert (TREE_CODE (decl) == VAR_DECL);
6683   return decl;
6684 }
6685
6686
6687 /* Returns the binfo for the primary base of BINFO.  If the resulting
6688    BINFO is a virtual base, and it is inherited elsewhere in the
6689    hierarchy, then the returned binfo might not be the primary base of
6690    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6691    BINFO_LOST_PRIMARY_P to be sure.  */
6692
6693 static tree
6694 get_primary_binfo (tree binfo)
6695 {
6696   tree primary_base;
6697
6698   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6699   if (!primary_base)
6700     return NULL_TREE;
6701
6702   return copied_binfo (primary_base, binfo);
6703 }
6704
6705 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6706
6707 static int
6708 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6709 {
6710   if (!indented_p)
6711     fprintf (stream, "%*s", indent, "");
6712   return 1;
6713 }
6714
6715 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6716    INDENT should be zero when called from the top level; it is
6717    incremented recursively.  IGO indicates the next expected BINFO in
6718    inheritance graph ordering.  */
6719
6720 static tree
6721 dump_class_hierarchy_r (FILE *stream,
6722                         int flags,
6723                         tree binfo,
6724                         tree igo,
6725                         int indent)
6726 {
6727   int indented = 0;
6728   tree base_binfo;
6729   int i;
6730
6731   indented = maybe_indent_hierarchy (stream, indent, 0);
6732   fprintf (stream, "%s (0x%lx) ",
6733            type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6734            (unsigned long) binfo);
6735   if (binfo != igo)
6736     {
6737       fprintf (stream, "alternative-path\n");
6738       return igo;
6739     }
6740   igo = TREE_CHAIN (binfo);
6741
6742   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6743            tree_low_cst (BINFO_OFFSET (binfo), 0));
6744   if (is_empty_class (BINFO_TYPE (binfo)))
6745     fprintf (stream, " empty");
6746   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6747     fprintf (stream, " nearly-empty");
6748   if (BINFO_VIRTUAL_P (binfo))
6749     fprintf (stream, " virtual");
6750   fprintf (stream, "\n");
6751
6752   indented = 0;
6753   if (BINFO_PRIMARY_P (binfo))
6754     {
6755       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6756       fprintf (stream, " primary-for %s (0x%lx)",
6757                type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
6758                                TFF_PLAIN_IDENTIFIER),
6759                (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
6760     }
6761   if (BINFO_LOST_PRIMARY_P (binfo))
6762     {
6763       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6764       fprintf (stream, " lost-primary");
6765     }
6766   if (indented)
6767     fprintf (stream, "\n");
6768
6769   if (!(flags & TDF_SLIM))
6770     {
6771       int indented = 0;
6772
6773       if (BINFO_SUBVTT_INDEX (binfo))
6774         {
6775           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6776           fprintf (stream, " subvttidx=%s",
6777                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6778                                    TFF_PLAIN_IDENTIFIER));
6779         }
6780       if (BINFO_VPTR_INDEX (binfo))
6781         {
6782           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6783           fprintf (stream, " vptridx=%s",
6784                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6785                                    TFF_PLAIN_IDENTIFIER));
6786         }
6787       if (BINFO_VPTR_FIELD (binfo))
6788         {
6789           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6790           fprintf (stream, " vbaseoffset=%s",
6791                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6792                                    TFF_PLAIN_IDENTIFIER));
6793         }
6794       if (BINFO_VTABLE (binfo))
6795         {
6796           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6797           fprintf (stream, " vptr=%s",
6798                    expr_as_string (BINFO_VTABLE (binfo),
6799                                    TFF_PLAIN_IDENTIFIER));
6800         }
6801
6802       if (indented)
6803         fprintf (stream, "\n");
6804     }
6805
6806   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
6807     igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
6808
6809   return igo;
6810 }
6811
6812 /* Dump the BINFO hierarchy for T.  */
6813
6814 static void
6815 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6816 {
6817   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6818   fprintf (stream, "   size=%lu align=%lu\n",
6819            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6820            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6821   fprintf (stream, "   base size=%lu base align=%lu\n",
6822            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6823                            / BITS_PER_UNIT),
6824            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6825                            / BITS_PER_UNIT));
6826   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6827   fprintf (stream, "\n");
6828 }
6829
6830 /* Debug interface to hierarchy dumping.  */
6831
6832 void
6833 debug_class (tree t)
6834 {
6835   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6836 }
6837
6838 static void
6839 dump_class_hierarchy (tree t)
6840 {
6841   int flags;
6842   FILE *stream = dump_begin (TDI_class, &flags);
6843
6844   if (stream)
6845     {
6846       dump_class_hierarchy_1 (stream, flags, t);
6847       dump_end (TDI_class, stream);
6848     }
6849 }
6850
6851 static void
6852 dump_array (FILE * stream, tree decl)
6853 {
6854   tree value;
6855   unsigned HOST_WIDE_INT ix;
6856   HOST_WIDE_INT elt;
6857   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6858
6859   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6860          / BITS_PER_UNIT);
6861   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6862   fprintf (stream, " %s entries",
6863            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6864                            TFF_PLAIN_IDENTIFIER));
6865   fprintf (stream, "\n");
6866
6867   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
6868                               ix, value)
6869     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6870              expr_as_string (value, TFF_PLAIN_IDENTIFIER));
6871 }
6872
6873 static void
6874 dump_vtable (tree t, tree binfo, tree vtable)
6875 {
6876   int flags;
6877   FILE *stream = dump_begin (TDI_class, &flags);
6878
6879   if (!stream)
6880     return;
6881
6882   if (!(flags & TDF_SLIM))
6883     {
6884       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6885
6886       fprintf (stream, "%s for %s",
6887                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6888                type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
6889       if (ctor_vtbl_p)
6890         {
6891           if (!BINFO_VIRTUAL_P (binfo))
6892             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6893           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6894         }
6895       fprintf (stream, "\n");
6896       dump_array (stream, vtable);
6897       fprintf (stream, "\n");
6898     }
6899
6900   dump_end (TDI_class, stream);
6901 }
6902
6903 static void
6904 dump_vtt (tree t, tree vtt)
6905 {
6906   int flags;
6907   FILE *stream = dump_begin (TDI_class, &flags);
6908
6909   if (!stream)
6910     return;
6911
6912   if (!(flags & TDF_SLIM))
6913     {
6914       fprintf (stream, "VTT for %s\n",
6915                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6916       dump_array (stream, vtt);
6917       fprintf (stream, "\n");
6918     }
6919
6920   dump_end (TDI_class, stream);
6921 }
6922
6923 /* Dump a function or thunk and its thunkees.  */
6924
6925 static void
6926 dump_thunk (FILE *stream, int indent, tree thunk)
6927 {
6928   static const char spaces[] = "        ";
6929   tree name = DECL_NAME (thunk);
6930   tree thunks;
6931
6932   fprintf (stream, "%.*s%p %s %s", indent, spaces,
6933            (void *)thunk,
6934            !DECL_THUNK_P (thunk) ? "function"
6935            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6936            name ? IDENTIFIER_POINTER (name) : "<unset>");
6937   if (DECL_THUNK_P (thunk))
6938     {
6939       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6940       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6941
6942       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6943       if (!virtual_adjust)
6944         /*NOP*/;
6945       else if (DECL_THIS_THUNK_P (thunk))
6946         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
6947                  tree_low_cst (virtual_adjust, 0));
6948       else
6949         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6950                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6951                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6952       if (THUNK_ALIAS (thunk))
6953         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6954     }
6955   fprintf (stream, "\n");
6956   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6957     dump_thunk (stream, indent + 2, thunks);
6958 }
6959
6960 /* Dump the thunks for FN.  */
6961
6962 void
6963 debug_thunks (tree fn)
6964 {
6965   dump_thunk (stderr, 0, fn);
6966 }
6967
6968 /* Virtual function table initialization.  */
6969
6970 /* Create all the necessary vtables for T and its base classes.  */
6971
6972 static void
6973 finish_vtbls (tree t)
6974 {
6975   tree list;
6976   tree vbase;
6977
6978   /* We lay out the primary and secondary vtables in one contiguous
6979      vtable.  The primary vtable is first, followed by the non-virtual
6980      secondary vtables in inheritance graph order.  */
6981   list = build_tree_list (BINFO_VTABLE (TYPE_BINFO (t)), NULL_TREE);
6982   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6983                          TYPE_BINFO (t), t, list);
6984
6985   /* Then come the virtual bases, also in inheritance graph order.  */
6986   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6987     {
6988       if (!BINFO_VIRTUAL_P (vbase))
6989         continue;
6990       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6991     }
6992
6993   if (BINFO_VTABLE (TYPE_BINFO (t)))
6994     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6995 }
6996
6997 /* Initialize the vtable for BINFO with the INITS.  */
6998
6999 static void
7000 initialize_vtable (tree binfo, tree inits)
7001 {
7002   tree decl;
7003
7004   layout_vtable_decl (binfo, list_length (inits));
7005   decl = get_vtbl_decl_for_binfo (binfo);
7006   initialize_artificial_var (decl, inits);
7007   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
7008 }
7009
7010 /* Build the VTT (virtual table table) for T.
7011    A class requires a VTT if it has virtual bases.
7012
7013    This holds
7014    1 - primary virtual pointer for complete object T
7015    2 - secondary VTTs for each direct non-virtual base of T which requires a
7016        VTT
7017    3 - secondary virtual pointers for each direct or indirect base of T which
7018        has virtual bases or is reachable via a virtual path from T.
7019    4 - secondary VTTs for each direct or indirect virtual base of T.
7020
7021    Secondary VTTs look like complete object VTTs without part 4.  */
7022
7023 static void
7024 build_vtt (tree t)
7025 {
7026   tree inits;
7027   tree type;
7028   tree vtt;
7029   tree index;
7030
7031   /* Build up the initializers for the VTT.  */
7032   inits = NULL_TREE;
7033   index = size_zero_node;
7034   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
7035
7036   /* If we didn't need a VTT, we're done.  */
7037   if (!inits)
7038     return;
7039
7040   /* Figure out the type of the VTT.  */
7041   type = build_index_type (size_int (list_length (inits) - 1));
7042   type = build_cplus_array_type (const_ptr_type_node, type);
7043
7044   /* Now, build the VTT object itself.  */
7045   vtt = build_vtable (t, mangle_vtt_for_type (t), type);
7046   initialize_artificial_var (vtt, inits);
7047   /* Add the VTT to the vtables list.  */
7048   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
7049   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
7050
7051   dump_vtt (t, vtt);
7052 }
7053
7054 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7055    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7056    and CHAIN the vtable pointer for this binfo after construction is
7057    complete.  VALUE can also be another BINFO, in which case we recurse.  */
7058
7059 static tree
7060 binfo_ctor_vtable (tree binfo)
7061 {
7062   tree vt;
7063
7064   while (1)
7065     {
7066       vt = BINFO_VTABLE (binfo);
7067       if (TREE_CODE (vt) == TREE_LIST)
7068         vt = TREE_VALUE (vt);
7069       if (TREE_CODE (vt) == TREE_BINFO)
7070         binfo = vt;
7071       else
7072         break;
7073     }
7074
7075   return vt;
7076 }
7077
7078 /* Data for secondary VTT initialization.  */
7079 typedef struct secondary_vptr_vtt_init_data_s
7080 {
7081   /* Is this the primary VTT? */
7082   bool top_level_p;
7083
7084   /* Current index into the VTT.  */
7085   tree index;
7086
7087   /* TREE_LIST of initializers built up.  */
7088   tree inits;
7089
7090   /* The type being constructed by this secondary VTT.  */
7091   tree type_being_constructed;
7092 } secondary_vptr_vtt_init_data;
7093
7094 /* Recursively build the VTT-initializer for BINFO (which is in the
7095    hierarchy dominated by T).  INITS points to the end of the initializer
7096    list to date.  INDEX is the VTT index where the next element will be
7097    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7098    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
7099    for virtual bases of T. When it is not so, we build the constructor
7100    vtables for the BINFO-in-T variant.  */
7101
7102 static tree *
7103 build_vtt_inits (tree binfo, tree t, tree *inits, tree *index)
7104 {
7105   int i;
7106   tree b;
7107   tree init;
7108   tree secondary_vptrs;
7109   secondary_vptr_vtt_init_data data;
7110   int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7111
7112   /* We only need VTTs for subobjects with virtual bases.  */
7113   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7114     return inits;
7115
7116   /* We need to use a construction vtable if this is not the primary
7117      VTT.  */
7118   if (!top_level_p)
7119     {
7120       build_ctor_vtbl_group (binfo, t);
7121
7122       /* Record the offset in the VTT where this sub-VTT can be found.  */
7123       BINFO_SUBVTT_INDEX (binfo) = *index;
7124     }
7125
7126   /* Add the address of the primary vtable for the complete object.  */
7127   init = binfo_ctor_vtable (binfo);
7128   *inits = build_tree_list (NULL_TREE, init);
7129   inits = &TREE_CHAIN (*inits);
7130   if (top_level_p)
7131     {
7132       gcc_assert (!BINFO_VPTR_INDEX (binfo));
7133       BINFO_VPTR_INDEX (binfo) = *index;
7134     }
7135   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
7136
7137   /* Recursively add the secondary VTTs for non-virtual bases.  */
7138   for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
7139     if (!BINFO_VIRTUAL_P (b))
7140       inits = build_vtt_inits (b, t, inits, index);
7141
7142   /* Add secondary virtual pointers for all subobjects of BINFO with
7143      either virtual bases or reachable along a virtual path, except
7144      subobjects that are non-virtual primary bases.  */
7145   data.top_level_p = top_level_p;
7146   data.index = *index;
7147   data.inits = NULL;
7148   data.type_being_constructed = BINFO_TYPE (binfo);
7149
7150   dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
7151
7152   *index = data.index;
7153
7154   /* The secondary vptrs come back in reverse order.  After we reverse
7155      them, and add the INITS, the last init will be the first element
7156      of the chain.  */
7157   secondary_vptrs = data.inits;
7158   if (secondary_vptrs)
7159     {
7160       *inits = nreverse (secondary_vptrs);
7161       inits = &TREE_CHAIN (secondary_vptrs);
7162       gcc_assert (*inits == NULL_TREE);
7163     }
7164
7165   if (top_level_p)
7166     /* Add the secondary VTTs for virtual bases in inheritance graph
7167        order.  */
7168     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
7169       {
7170         if (!BINFO_VIRTUAL_P (b))
7171           continue;
7172
7173         inits = build_vtt_inits (b, t, inits, index);
7174       }
7175   else
7176     /* Remove the ctor vtables we created.  */
7177     dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
7178
7179   return inits;
7180 }
7181
7182 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo for the base
7183    in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure.  */
7184
7185 static tree
7186 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
7187 {
7188   secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
7189
7190   /* We don't care about bases that don't have vtables.  */
7191   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7192     return dfs_skip_bases;
7193
7194   /* We're only interested in proper subobjects of the type being
7195      constructed.  */
7196   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
7197     return NULL_TREE;
7198
7199   /* We're only interested in bases with virtual bases or reachable
7200      via a virtual path from the type being constructed.  */
7201   if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7202         || binfo_via_virtual (binfo, data->type_being_constructed)))
7203     return dfs_skip_bases;
7204
7205   /* We're not interested in non-virtual primary bases.  */
7206   if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
7207     return NULL_TREE;
7208
7209   /* Record the index where this secondary vptr can be found.  */
7210   if (data->top_level_p)
7211     {
7212       gcc_assert (!BINFO_VPTR_INDEX (binfo));
7213       BINFO_VPTR_INDEX (binfo) = data->index;
7214
7215       if (BINFO_VIRTUAL_P (binfo))
7216         {
7217           /* It's a primary virtual base, and this is not a
7218              construction vtable.  Find the base this is primary of in
7219              the inheritance graph, and use that base's vtable
7220              now.  */
7221           while (BINFO_PRIMARY_P (binfo))
7222             binfo = BINFO_INHERITANCE_CHAIN (binfo);
7223         }
7224     }
7225
7226   /* Add the initializer for the secondary vptr itself.  */
7227   data->inits = tree_cons (NULL_TREE, binfo_ctor_vtable (binfo), data->inits);
7228
7229   /* Advance the vtt index.  */
7230   data->index = size_binop (PLUS_EXPR, data->index,
7231                             TYPE_SIZE_UNIT (ptr_type_node));
7232
7233   return NULL_TREE;
7234 }
7235
7236 /* Called from build_vtt_inits via dfs_walk. After building
7237    constructor vtables and generating the sub-vtt from them, we need
7238    to restore the BINFO_VTABLES that were scribbled on.  DATA is the
7239    binfo of the base whose sub vtt was generated.  */
7240
7241 static tree
7242 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7243 {
7244   tree vtable = BINFO_VTABLE (binfo);
7245
7246   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7247     /* If this class has no vtable, none of its bases do.  */
7248     return dfs_skip_bases;
7249
7250   if (!vtable)
7251     /* This might be a primary base, so have no vtable in this
7252        hierarchy.  */
7253     return NULL_TREE;
7254
7255   /* If we scribbled the construction vtable vptr into BINFO, clear it
7256      out now.  */
7257   if (TREE_CODE (vtable) == TREE_LIST
7258       && (TREE_PURPOSE (vtable) == (tree) data))
7259     BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
7260
7261   return NULL_TREE;
7262 }
7263
7264 /* Build the construction vtable group for BINFO which is in the
7265    hierarchy dominated by T.  */
7266
7267 static void
7268 build_ctor_vtbl_group (tree binfo, tree t)
7269 {
7270   tree list;
7271   tree type;
7272   tree vtbl;
7273   tree inits;
7274   tree id;
7275   tree vbase;
7276
7277   /* See if we've already created this construction vtable group.  */
7278   id = mangle_ctor_vtbl_for_type (t, binfo);
7279   if (IDENTIFIER_GLOBAL_VALUE (id))
7280     return;
7281
7282   gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
7283   /* Build a version of VTBL (with the wrong type) for use in
7284      constructing the addresses of secondary vtables in the
7285      construction vtable group.  */
7286   vtbl = build_vtable (t, id, ptr_type_node);
7287   DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
7288   list = build_tree_list (vtbl, NULL_TREE);
7289   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7290                          binfo, t, list);
7291
7292   /* Add the vtables for each of our virtual bases using the vbase in T
7293      binfo.  */
7294   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7295        vbase;
7296        vbase = TREE_CHAIN (vbase))
7297     {
7298       tree b;
7299
7300       if (!BINFO_VIRTUAL_P (vbase))
7301         continue;
7302       b = copied_binfo (vbase, binfo);
7303
7304       accumulate_vtbl_inits (b, vbase, binfo, t, list);
7305     }
7306   inits = TREE_VALUE (list);
7307
7308   /* Figure out the type of the construction vtable.  */
7309   type = build_index_type (size_int (list_length (inits) - 1));
7310   type = build_cplus_array_type (vtable_entry_type, type);
7311   layout_type (type);
7312   TREE_TYPE (vtbl) = type;
7313   DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE;
7314   layout_decl (vtbl, 0);
7315
7316   /* Initialize the construction vtable.  */
7317   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7318   initialize_artificial_var (vtbl, inits);
7319   dump_vtable (t, binfo, vtbl);
7320 }
7321
7322 /* Add the vtbl initializers for BINFO (and its bases other than
7323    non-virtual primaries) to the list of INITS.  BINFO is in the
7324    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
7325    the constructor the vtbl inits should be accumulated for. (If this
7326    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7327    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7328    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7329    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7330    but are not necessarily the same in terms of layout.  */
7331
7332 static void
7333 accumulate_vtbl_inits (tree binfo,
7334                        tree orig_binfo,
7335                        tree rtti_binfo,
7336                        tree t,
7337                        tree inits)
7338 {
7339   int i;
7340   tree base_binfo;
7341   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7342
7343   gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
7344
7345   /* If it doesn't have a vptr, we don't do anything.  */
7346   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7347     return;
7348
7349   /* If we're building a construction vtable, we're not interested in
7350      subobjects that don't require construction vtables.  */
7351   if (ctor_vtbl_p
7352       && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7353       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7354     return;
7355
7356   /* Build the initializers for the BINFO-in-T vtable.  */
7357   TREE_VALUE (inits)
7358     = chainon (TREE_VALUE (inits),
7359                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7360                                           rtti_binfo, t, inits));
7361
7362   /* Walk the BINFO and its bases.  We walk in preorder so that as we
7363      initialize each vtable we can figure out at what offset the
7364      secondary vtable lies from the primary vtable.  We can't use
7365      dfs_walk here because we need to iterate through bases of BINFO
7366      and RTTI_BINFO simultaneously.  */
7367   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7368     {
7369       /* Skip virtual bases.  */
7370       if (BINFO_VIRTUAL_P (base_binfo))
7371         continue;
7372       accumulate_vtbl_inits (base_binfo,
7373                              BINFO_BASE_BINFO (orig_binfo, i),
7374                              rtti_binfo, t,
7375                              inits);
7376     }
7377 }
7378
7379 /* Called from accumulate_vtbl_inits.  Returns the initializers for
7380    the BINFO vtable.  */
7381
7382 static tree
7383 dfs_accumulate_vtbl_inits (tree binfo,
7384                            tree orig_binfo,
7385                            tree rtti_binfo,
7386                            tree t,
7387                            tree l)
7388 {
7389   tree inits = NULL_TREE;
7390   tree vtbl = NULL_TREE;
7391   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7392
7393   if (ctor_vtbl_p
7394       && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7395     {
7396       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7397          primary virtual base.  If it is not the same primary in
7398          the hierarchy of T, we'll need to generate a ctor vtable
7399          for it, to place at its location in T.  If it is the same
7400          primary, we still need a VTT entry for the vtable, but it
7401          should point to the ctor vtable for the base it is a
7402          primary for within the sub-hierarchy of RTTI_BINFO.
7403
7404          There are three possible cases:
7405
7406          1) We are in the same place.
7407          2) We are a primary base within a lost primary virtual base of
7408          RTTI_BINFO.
7409          3) We are primary to something not a base of RTTI_BINFO.  */
7410
7411       tree b;
7412       tree last = NULL_TREE;
7413
7414       /* First, look through the bases we are primary to for RTTI_BINFO
7415          or a virtual base.  */
7416       b = binfo;
7417       while (BINFO_PRIMARY_P (b))
7418         {
7419           b = BINFO_INHERITANCE_CHAIN (b);
7420           last = b;
7421           if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7422             goto found;
7423         }
7424       /* If we run out of primary links, keep looking down our
7425          inheritance chain; we might be an indirect primary.  */
7426       for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7427         if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7428           break;
7429     found:
7430
7431       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7432          base B and it is a base of RTTI_BINFO, this is case 2.  In
7433          either case, we share our vtable with LAST, i.e. the
7434          derived-most base within B of which we are a primary.  */
7435       if (b == rtti_binfo
7436           || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7437         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7438            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7439            binfo_ctor_vtable after everything's been set up.  */
7440         vtbl = last;
7441
7442       /* Otherwise, this is case 3 and we get our own.  */
7443     }
7444   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7445     return inits;
7446
7447   if (!vtbl)
7448     {
7449       tree index;
7450       int non_fn_entries;
7451
7452       /* Compute the initializer for this vtable.  */
7453       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7454                                       &non_fn_entries);
7455
7456       /* Figure out the position to which the VPTR should point.  */
7457       vtbl = TREE_PURPOSE (l);
7458       vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, vtbl);
7459       index = size_binop (PLUS_EXPR,
7460                           size_int (non_fn_entries),
7461                           size_int (list_length (TREE_VALUE (l))));
7462       index = size_binop (MULT_EXPR,
7463                           TYPE_SIZE_UNIT (vtable_entry_type),
7464                           index);
7465       vtbl = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7466     }
7467
7468   if (ctor_vtbl_p)
7469     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7470        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7471        straighten this out.  */
7472     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7473   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7474     inits = NULL_TREE;
7475   else
7476      /* For an ordinary vtable, set BINFO_VTABLE.  */
7477     BINFO_VTABLE (binfo) = vtbl;
7478
7479   return inits;
7480 }
7481
7482 static GTY(()) tree abort_fndecl_addr;
7483
7484 /* Construct the initializer for BINFO's virtual function table.  BINFO
7485    is part of the hierarchy dominated by T.  If we're building a
7486    construction vtable, the ORIG_BINFO is the binfo we should use to
7487    find the actual function pointers to put in the vtable - but they
7488    can be overridden on the path to most-derived in the graph that
7489    ORIG_BINFO belongs.  Otherwise,
7490    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7491    BINFO that should be indicated by the RTTI information in the
7492    vtable; it will be a base class of T, rather than T itself, if we
7493    are building a construction vtable.
7494
7495    The value returned is a TREE_LIST suitable for wrapping in a
7496    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7497    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7498    number of non-function entries in the vtable.
7499
7500    It might seem that this function should never be called with a
7501    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7502    base is always subsumed by a derived class vtable.  However, when
7503    we are building construction vtables, we do build vtables for
7504    primary bases; we need these while the primary base is being
7505    constructed.  */
7506
7507 static tree
7508 build_vtbl_initializer (tree binfo,
7509                         tree orig_binfo,
7510                         tree t,
7511                         tree rtti_binfo,
7512                         int* non_fn_entries_p)
7513 {
7514   tree v, b;
7515   tree vfun_inits;
7516   vtbl_init_data vid;
7517   unsigned ix;
7518   tree vbinfo;
7519   VEC(tree,gc) *vbases;
7520
7521   /* Initialize VID.  */
7522   memset (&vid, 0, sizeof (vid));
7523   vid.binfo = binfo;
7524   vid.derived = t;
7525   vid.rtti_binfo = rtti_binfo;
7526   vid.last_init = &vid.inits;
7527   vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7528   vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7529   vid.generate_vcall_entries = true;
7530   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7531   vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7532
7533   /* Add entries to the vtable for RTTI.  */
7534   build_rtti_vtbl_entries (binfo, &vid);
7535
7536   /* Create an array for keeping track of the functions we've
7537      processed.  When we see multiple functions with the same
7538      signature, we share the vcall offsets.  */
7539   vid.fns = VEC_alloc (tree, gc, 32);
7540   /* Add the vcall and vbase offset entries.  */
7541   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7542
7543   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7544      build_vbase_offset_vtbl_entries.  */
7545   for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7546        VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7547     BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7548
7549   /* If the target requires padding between data entries, add that now.  */
7550   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7551     {
7552       tree cur, *prev;
7553
7554       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7555         {
7556           tree add = cur;
7557           int i;
7558
7559           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7560             add = tree_cons (NULL_TREE,
7561                              build1 (NOP_EXPR, vtable_entry_type,
7562                                      null_pointer_node),
7563                              add);
7564           *prev = add;
7565         }
7566     }
7567
7568   if (non_fn_entries_p)
7569     *non_fn_entries_p = list_length (vid.inits);
7570
7571   /* Go through all the ordinary virtual functions, building up
7572      initializers.  */
7573   vfun_inits = NULL_TREE;
7574   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7575     {
7576       tree delta;
7577       tree vcall_index;
7578       tree fn, fn_original;
7579       tree init = NULL_TREE;
7580
7581       fn = BV_FN (v);
7582       fn_original = fn;
7583       if (DECL_THUNK_P (fn))
7584         {
7585           if (!DECL_NAME (fn))
7586             finish_thunk (fn);
7587           if (THUNK_ALIAS (fn))
7588             {
7589               fn = THUNK_ALIAS (fn);
7590               BV_FN (v) = fn;
7591             }
7592           fn_original = THUNK_TARGET (fn);
7593         }
7594
7595       /* If the only definition of this function signature along our
7596          primary base chain is from a lost primary, this vtable slot will
7597          never be used, so just zero it out.  This is important to avoid
7598          requiring extra thunks which cannot be generated with the function.
7599
7600          We first check this in update_vtable_entry_for_fn, so we handle
7601          restored primary bases properly; we also need to do it here so we
7602          zero out unused slots in ctor vtables, rather than filling them
7603          with erroneous values (though harmless, apart from relocation
7604          costs).  */
7605       for (b = binfo; ; b = get_primary_binfo (b))
7606         {
7607           /* We found a defn before a lost primary; go ahead as normal.  */
7608           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7609             break;
7610
7611           /* The nearest definition is from a lost primary; clear the
7612              slot.  */
7613           if (BINFO_LOST_PRIMARY_P (b))
7614             {
7615               init = size_zero_node;
7616               break;
7617             }
7618         }
7619
7620       if (! init)
7621         {
7622           /* Pull the offset for `this', and the function to call, out of
7623              the list.  */
7624           delta = BV_DELTA (v);
7625           vcall_index = BV_VCALL_INDEX (v);
7626
7627           gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7628           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7629
7630           /* You can't call an abstract virtual function; it's abstract.
7631              So, we replace these functions with __pure_virtual.  */
7632           if (DECL_PURE_VIRTUAL_P (fn_original))
7633             {
7634               fn = abort_fndecl;
7635               if (abort_fndecl_addr == NULL)
7636                 abort_fndecl_addr = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7637               init = abort_fndecl_addr;
7638             }
7639           else
7640             {
7641               if (!integer_zerop (delta) || vcall_index)
7642                 {
7643                   fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7644                   if (!DECL_NAME (fn))
7645                     finish_thunk (fn);
7646                 }
7647               /* Take the address of the function, considering it to be of an
7648                  appropriate generic type.  */
7649               init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7650             }
7651         }
7652
7653       /* And add it to the chain of initializers.  */
7654       if (TARGET_VTABLE_USES_DESCRIPTORS)
7655         {
7656           int i;
7657           if (init == size_zero_node)
7658             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7659               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7660           else
7661             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7662               {
7663                 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7664                                      TREE_OPERAND (init, 0),
7665                                      build_int_cst (NULL_TREE, i));
7666                 TREE_CONSTANT (fdesc) = 1;
7667
7668                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7669               }
7670         }
7671       else
7672         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7673     }
7674
7675   /* The initializers for virtual functions were built up in reverse
7676      order; straighten them out now.  */
7677   vfun_inits = nreverse (vfun_inits);
7678
7679   /* The negative offset initializers are also in reverse order.  */
7680   vid.inits = nreverse (vid.inits);
7681
7682   /* Chain the two together.  */
7683   return chainon (vid.inits, vfun_inits);
7684 }
7685
7686 /* Adds to vid->inits the initializers for the vbase and vcall
7687    offsets in BINFO, which is in the hierarchy dominated by T.  */
7688
7689 static void
7690 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7691 {
7692   tree b;
7693
7694   /* If this is a derived class, we must first create entries
7695      corresponding to the primary base class.  */
7696   b = get_primary_binfo (binfo);
7697   if (b)
7698     build_vcall_and_vbase_vtbl_entries (b, vid);
7699
7700   /* Add the vbase entries for this base.  */
7701   build_vbase_offset_vtbl_entries (binfo, vid);
7702   /* Add the vcall entries for this base.  */
7703   build_vcall_offset_vtbl_entries (binfo, vid);
7704 }
7705
7706 /* Returns the initializers for the vbase offset entries in the vtable
7707    for BINFO (which is part of the class hierarchy dominated by T), in
7708    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7709    where the next vbase offset will go.  */
7710
7711 static void
7712 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7713 {
7714   tree vbase;
7715   tree t;
7716   tree non_primary_binfo;
7717
7718   /* If there are no virtual baseclasses, then there is nothing to
7719      do.  */
7720   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7721     return;
7722
7723   t = vid->derived;
7724
7725   /* We might be a primary base class.  Go up the inheritance hierarchy
7726      until we find the most derived class of which we are a primary base:
7727      it is the offset of that which we need to use.  */
7728   non_primary_binfo = binfo;
7729   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7730     {
7731       tree b;
7732
7733       /* If we have reached a virtual base, then it must be a primary
7734          base (possibly multi-level) of vid->binfo, or we wouldn't
7735          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7736          might be a lost primary, so just skip down to vid->binfo.  */
7737       if (BINFO_VIRTUAL_P (non_primary_binfo))
7738         {
7739           non_primary_binfo = vid->binfo;
7740           break;
7741         }
7742
7743       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7744       if (get_primary_binfo (b) != non_primary_binfo)
7745         break;
7746       non_primary_binfo = b;
7747     }
7748
7749   /* Go through the virtual bases, adding the offsets.  */
7750   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7751        vbase;
7752        vbase = TREE_CHAIN (vbase))
7753     {
7754       tree b;
7755       tree delta;
7756
7757       if (!BINFO_VIRTUAL_P (vbase))
7758         continue;
7759
7760       /* Find the instance of this virtual base in the complete
7761          object.  */
7762       b = copied_binfo (vbase, binfo);
7763
7764       /* If we've already got an offset for this virtual base, we
7765          don't need another one.  */
7766       if (BINFO_VTABLE_PATH_MARKED (b))
7767         continue;
7768       BINFO_VTABLE_PATH_MARKED (b) = 1;
7769
7770       /* Figure out where we can find this vbase offset.  */
7771       delta = size_binop (MULT_EXPR,
7772                           vid->index,
7773                           convert (ssizetype,
7774                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7775       if (vid->primary_vtbl_p)
7776         BINFO_VPTR_FIELD (b) = delta;
7777
7778       if (binfo != TYPE_BINFO (t))
7779         /* The vbase offset had better be the same.  */
7780         gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
7781
7782       /* The next vbase will come at a more negative offset.  */
7783       vid->index = size_binop (MINUS_EXPR, vid->index,
7784                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7785
7786       /* The initializer is the delta from BINFO to this virtual base.
7787          The vbase offsets go in reverse inheritance-graph order, and
7788          we are walking in inheritance graph order so these end up in
7789          the right order.  */
7790       delta = size_diffop_loc (input_location,
7791                            BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7792
7793       *vid->last_init
7794         = build_tree_list (NULL_TREE,
7795                            fold_build1_loc (input_location, NOP_EXPR,
7796                                         vtable_entry_type,
7797                                         delta));
7798       vid->last_init = &TREE_CHAIN (*vid->last_init);
7799     }
7800 }
7801
7802 /* Adds the initializers for the vcall offset entries in the vtable
7803    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7804    to VID->INITS.  */
7805
7806 static void
7807 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7808 {
7809   /* We only need these entries if this base is a virtual base.  We
7810      compute the indices -- but do not add to the vtable -- when
7811      building the main vtable for a class.  */
7812   if (binfo == TYPE_BINFO (vid->derived)
7813       || (BINFO_VIRTUAL_P (binfo)
7814           /* If BINFO is RTTI_BINFO, then (since BINFO does not
7815              correspond to VID->DERIVED), we are building a primary
7816              construction virtual table.  Since this is a primary
7817              virtual table, we do not need the vcall offsets for
7818              BINFO.  */
7819           && binfo != vid->rtti_binfo))
7820     {
7821       /* We need a vcall offset for each of the virtual functions in this
7822          vtable.  For example:
7823
7824            class A { virtual void f (); };
7825            class B1 : virtual public A { virtual void f (); };
7826            class B2 : virtual public A { virtual void f (); };
7827            class C: public B1, public B2 { virtual void f (); };
7828
7829          A C object has a primary base of B1, which has a primary base of A.  A
7830          C also has a secondary base of B2, which no longer has a primary base
7831          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7832          A, which will adjust the A* to a B2* to call f.  We have no way of
7833          knowing what (or even whether) this offset will be when we define B2,
7834          so we store this "vcall offset" in the A sub-vtable and look it up in
7835          a "virtual thunk" for B2::f.
7836
7837          We need entries for all the functions in our primary vtable and
7838          in our non-virtual bases' secondary vtables.  */
7839       vid->vbase = binfo;
7840       /* If we are just computing the vcall indices -- but do not need
7841          the actual entries -- not that.  */
7842       if (!BINFO_VIRTUAL_P (binfo))
7843         vid->generate_vcall_entries = false;
7844       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7845       add_vcall_offset_vtbl_entries_r (binfo, vid);
7846     }
7847 }
7848
7849 /* Build vcall offsets, starting with those for BINFO.  */
7850
7851 static void
7852 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7853 {
7854   int i;
7855   tree primary_binfo;
7856   tree base_binfo;
7857
7858   /* Don't walk into virtual bases -- except, of course, for the
7859      virtual base for which we are building vcall offsets.  Any
7860      primary virtual base will have already had its offsets generated
7861      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7862   if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
7863     return;
7864
7865   /* If BINFO has a primary base, process it first.  */
7866   primary_binfo = get_primary_binfo (binfo);
7867   if (primary_binfo)
7868     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7869
7870   /* Add BINFO itself to the list.  */
7871   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7872
7873   /* Scan the non-primary bases of BINFO.  */
7874   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7875     if (base_binfo != primary_binfo)
7876       add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7877 }
7878
7879 /* Called from build_vcall_offset_vtbl_entries_r.  */
7880
7881 static void
7882 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7883 {
7884   /* Make entries for the rest of the virtuals.  */
7885   if (abi_version_at_least (2))
7886     {
7887       tree orig_fn;
7888
7889       /* The ABI requires that the methods be processed in declaration
7890          order.  G++ 3.2 used the order in the vtable.  */
7891       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7892            orig_fn;
7893            orig_fn = TREE_CHAIN (orig_fn))
7894         if (DECL_VINDEX (orig_fn))
7895           add_vcall_offset (orig_fn, binfo, vid);
7896     }
7897   else
7898     {
7899       tree derived_virtuals;
7900       tree base_virtuals;
7901       tree orig_virtuals;
7902       /* If BINFO is a primary base, the most derived class which has
7903          BINFO as a primary base; otherwise, just BINFO.  */
7904       tree non_primary_binfo;
7905
7906       /* We might be a primary base class.  Go up the inheritance hierarchy
7907          until we find the most derived class of which we are a primary base:
7908          it is the BINFO_VIRTUALS there that we need to consider.  */
7909       non_primary_binfo = binfo;
7910       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7911         {
7912           tree b;
7913
7914           /* If we have reached a virtual base, then it must be vid->vbase,
7915              because we ignore other virtual bases in
7916              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7917              base (possibly multi-level) of vid->binfo, or we wouldn't
7918              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7919              might be a lost primary, so just skip down to vid->binfo.  */
7920           if (BINFO_VIRTUAL_P (non_primary_binfo))
7921             {
7922               gcc_assert (non_primary_binfo == vid->vbase);
7923               non_primary_binfo = vid->binfo;
7924               break;
7925             }
7926
7927           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7928           if (get_primary_binfo (b) != non_primary_binfo)
7929             break;
7930           non_primary_binfo = b;
7931         }
7932
7933       if (vid->ctor_vtbl_p)
7934         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7935            where rtti_binfo is the most derived type.  */
7936         non_primary_binfo
7937           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7938
7939       for (base_virtuals = BINFO_VIRTUALS (binfo),
7940              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7941              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7942            base_virtuals;
7943            base_virtuals = TREE_CHAIN (base_virtuals),
7944              derived_virtuals = TREE_CHAIN (derived_virtuals),
7945              orig_virtuals = TREE_CHAIN (orig_virtuals))
7946         {
7947           tree orig_fn;
7948
7949           /* Find the declaration that originally caused this function to
7950              be present in BINFO_TYPE (binfo).  */
7951           orig_fn = BV_FN (orig_virtuals);
7952
7953           /* When processing BINFO, we only want to generate vcall slots for
7954              function slots introduced in BINFO.  So don't try to generate
7955              one if the function isn't even defined in BINFO.  */
7956           if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
7957             continue;
7958
7959           add_vcall_offset (orig_fn, binfo, vid);
7960         }
7961     }
7962 }
7963
7964 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7965
7966 static void
7967 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7968 {
7969   size_t i;
7970   tree vcall_offset;
7971   tree derived_entry;
7972
7973   /* If there is already an entry for a function with the same
7974      signature as FN, then we do not need a second vcall offset.
7975      Check the list of functions already present in the derived
7976      class vtable.  */
7977   for (i = 0; VEC_iterate (tree, vid->fns, i, derived_entry); ++i)
7978     {
7979       if (same_signature_p (derived_entry, orig_fn)
7980           /* We only use one vcall offset for virtual destructors,
7981              even though there are two virtual table entries.  */
7982           || (DECL_DESTRUCTOR_P (derived_entry)
7983               && DECL_DESTRUCTOR_P (orig_fn)))
7984         return;
7985     }
7986
7987   /* If we are building these vcall offsets as part of building
7988      the vtable for the most derived class, remember the vcall
7989      offset.  */
7990   if (vid->binfo == TYPE_BINFO (vid->derived))
7991     {
7992       tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
7993                                        CLASSTYPE_VCALL_INDICES (vid->derived),
7994                                        NULL);
7995       elt->purpose = orig_fn;
7996       elt->value = vid->index;
7997     }
7998
7999   /* The next vcall offset will be found at a more negative
8000      offset.  */
8001   vid->index = size_binop (MINUS_EXPR, vid->index,
8002                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
8003
8004   /* Keep track of this function.  */
8005   VEC_safe_push (tree, gc, vid->fns, orig_fn);
8006
8007   if (vid->generate_vcall_entries)
8008     {
8009       tree base;
8010       tree fn;
8011
8012       /* Find the overriding function.  */
8013       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
8014       if (fn == error_mark_node)
8015         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
8016                                integer_zero_node);
8017       else
8018         {
8019           base = TREE_VALUE (fn);
8020
8021           /* The vbase we're working on is a primary base of
8022              vid->binfo.  But it might be a lost primary, so its
8023              BINFO_OFFSET might be wrong, so we just use the
8024              BINFO_OFFSET from vid->binfo.  */
8025           vcall_offset = size_diffop_loc (input_location,
8026                                       BINFO_OFFSET (base),
8027                                       BINFO_OFFSET (vid->binfo));
8028           vcall_offset = fold_build1_loc (input_location,
8029                                       NOP_EXPR, vtable_entry_type,
8030                                       vcall_offset);
8031         }
8032       /* Add the initializer to the vtable.  */
8033       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
8034       vid->last_init = &TREE_CHAIN (*vid->last_init);
8035     }
8036 }
8037
8038 /* Return vtbl initializers for the RTTI entries corresponding to the
8039    BINFO's vtable.  The RTTI entries should indicate the object given
8040    by VID->rtti_binfo.  */
8041
8042 static void
8043 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
8044 {
8045   tree b;
8046   tree t;
8047   tree offset;
8048   tree decl;
8049   tree init;
8050
8051   t = BINFO_TYPE (vid->rtti_binfo);
8052
8053   /* To find the complete object, we will first convert to our most
8054      primary base, and then add the offset in the vtbl to that value.  */
8055   b = binfo;
8056   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
8057          && !BINFO_LOST_PRIMARY_P (b))
8058     {
8059       tree primary_base;
8060
8061       primary_base = get_primary_binfo (b);
8062       gcc_assert (BINFO_PRIMARY_P (primary_base)
8063                   && BINFO_INHERITANCE_CHAIN (primary_base) == b);
8064       b = primary_base;
8065     }
8066   offset = size_diffop_loc (input_location,
8067                         BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
8068
8069   /* The second entry is the address of the typeinfo object.  */
8070   if (flag_rtti)
8071     decl = build_address (get_tinfo_decl (t));
8072   else
8073     decl = integer_zero_node;
8074
8075   /* Convert the declaration to a type that can be stored in the
8076      vtable.  */
8077   init = build_nop (vfunc_ptr_type_node, decl);
8078   *vid->last_init = build_tree_list (NULL_TREE, init);
8079   vid->last_init = &TREE_CHAIN (*vid->last_init);
8080
8081   /* Add the offset-to-top entry.  It comes earlier in the vtable than
8082      the typeinfo entry.  Convert the offset to look like a
8083      function pointer, so that we can put it in the vtable.  */
8084   init = build_nop (vfunc_ptr_type_node, offset);
8085   *vid->last_init = build_tree_list (NULL_TREE, init);
8086   vid->last_init = &TREE_CHAIN (*vid->last_init);
8087 }
8088
8089 /* Fold a OBJ_TYPE_REF expression to the address of a function.
8090    KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF).  */
8091
8092 tree
8093 cp_fold_obj_type_ref (tree ref, tree known_type)
8094 {
8095   HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
8096   HOST_WIDE_INT i = 0;
8097   tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
8098   tree fndecl;
8099
8100   while (i != index)
8101     {
8102       i += (TARGET_VTABLE_USES_DESCRIPTORS
8103             ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
8104       v = TREE_CHAIN (v);
8105     }
8106
8107   fndecl = BV_FN (v);
8108
8109 #ifdef ENABLE_CHECKING
8110   gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
8111                                   DECL_VINDEX (fndecl)));
8112 #endif
8113
8114   cgraph_node (fndecl)->local.vtable_method = true;
8115
8116   return build_address (fndecl);
8117 }
8118
8119 #include "gt-cp-class.h"