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