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.  */
6168
6169       if (flags & tf_error)
6170         {
6171           tree match;
6172
6173           error ("converting overloaded function %qD to type %q#T is ambiguous",
6174                     DECL_NAME (OVL_FUNCTION (overload)),
6175                     target_type);
6176
6177           /* Since print_candidates expects the functions in the
6178              TREE_VALUE slot, we flip them here.  */
6179           for (match = matches; match; match = TREE_CHAIN (match))
6180             TREE_VALUE (match) = TREE_PURPOSE (match);
6181
6182           print_candidates (matches);
6183         }
6184
6185       return error_mark_node;
6186     }
6187
6188   /* Good, exactly one match.  Now, convert it to the correct type.  */
6189   fn = TREE_PURPOSE (matches);
6190
6191   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
6192       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
6193     {
6194       static int explained;
6195
6196       if (!(flags & tf_error))
6197         return error_mark_node;
6198
6199       permerror (input_location, "assuming pointer to member %qD", fn);
6200       if (!explained)
6201         {
6202           inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
6203           explained = 1;
6204         }
6205     }
6206
6207   /* If we're doing overload resolution purely for the purpose of
6208      determining conversion sequences, we should not consider the
6209      function used.  If this conversion sequence is selected, the
6210      function will be marked as used at this point.  */
6211   if (!(flags & tf_conv))
6212     {
6213       /* Make =delete work with SFINAE.  */
6214       if (DECL_DELETED_FN (fn) && !(flags & tf_error))
6215         return error_mark_node;
6216
6217       mark_used (fn);
6218     }
6219
6220   /* We could not check access to member functions when this
6221      expression was originally created since we did not know at that
6222      time to which function the expression referred.  */
6223   if (!(flags & tf_no_access_control)
6224       && DECL_FUNCTION_MEMBER_P (fn))
6225     {
6226       gcc_assert (access_path);
6227       perform_or_defer_access_check (access_path, fn, fn);
6228     }
6229
6230   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
6231     return cp_build_unary_op (ADDR_EXPR, fn, 0, flags);
6232   else
6233     {
6234       /* The target must be a REFERENCE_TYPE.  Above, cp_build_unary_op
6235          will mark the function as addressed, but here we must do it
6236          explicitly.  */
6237       cxx_mark_addressable (fn);
6238
6239       return fn;
6240     }
6241 }
6242
6243 /* This function will instantiate the type of the expression given in
6244    RHS to match the type of LHSTYPE.  If errors exist, then return
6245    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
6246    we complain on errors.  If we are not complaining, never modify rhs,
6247    as overload resolution wants to try many possible instantiations, in
6248    the hope that at least one will work.
6249
6250    For non-recursive calls, LHSTYPE should be a function, pointer to
6251    function, or a pointer to member function.  */
6252
6253 tree
6254 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6255 {
6256   tsubst_flags_t flags_in = flags;
6257   tree access_path = NULL_TREE;
6258
6259   flags &= ~tf_ptrmem_ok;
6260
6261   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
6262     {
6263       if (flags & tf_error)
6264         error ("not enough type information");
6265       return error_mark_node;
6266     }
6267
6268   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6269     {
6270       if (same_type_p (lhstype, TREE_TYPE (rhs)))
6271         return rhs;
6272       if (flag_ms_extensions
6273           && TYPE_PTRMEMFUNC_P (lhstype)
6274           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6275         /* Microsoft allows `A::f' to be resolved to a
6276            pointer-to-member.  */
6277         ;
6278       else
6279         {
6280           if (flags & tf_error)
6281             error ("argument of type %qT does not match %qT",
6282                    TREE_TYPE (rhs), lhstype);
6283           return error_mark_node;
6284         }
6285     }
6286
6287   if (TREE_CODE (rhs) == BASELINK)
6288     {
6289       access_path = BASELINK_ACCESS_BINFO (rhs);
6290       rhs = BASELINK_FUNCTIONS (rhs);
6291     }
6292
6293   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6294      deduce any type information.  */
6295   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6296     {
6297       if (flags & tf_error)
6298         error ("not enough type information");
6299       return error_mark_node;
6300     }
6301
6302   /* There only a few kinds of expressions that may have a type
6303      dependent on overload resolution.  */
6304   gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6305               || TREE_CODE (rhs) == COMPONENT_REF
6306               || TREE_CODE (rhs) == COMPOUND_EXPR
6307               || really_overloaded_fn (rhs));
6308
6309   /* We don't overwrite rhs if it is an overloaded function.
6310      Copying it would destroy the tree link.  */
6311   if (TREE_CODE (rhs) != OVERLOAD)
6312     rhs = copy_node (rhs);
6313
6314   /* This should really only be used when attempting to distinguish
6315      what sort of a pointer to function we have.  For now, any
6316      arithmetic operation which is not supported on pointers
6317      is rejected as an error.  */
6318
6319   switch (TREE_CODE (rhs))
6320     {
6321     case COMPONENT_REF:
6322       {
6323         tree member = TREE_OPERAND (rhs, 1);
6324
6325         member = instantiate_type (lhstype, member, flags);
6326         if (member != error_mark_node
6327             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6328           /* Do not lose object's side effects.  */
6329           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6330                          TREE_OPERAND (rhs, 0), member);
6331         return member;
6332       }
6333
6334     case OFFSET_REF:
6335       rhs = TREE_OPERAND (rhs, 1);
6336       if (BASELINK_P (rhs))
6337         return instantiate_type (lhstype, rhs, flags_in);
6338
6339       /* This can happen if we are forming a pointer-to-member for a
6340          member template.  */
6341       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6342
6343       /* Fall through.  */
6344
6345     case TEMPLATE_ID_EXPR:
6346       {
6347         tree fns = TREE_OPERAND (rhs, 0);
6348         tree args = TREE_OPERAND (rhs, 1);
6349
6350         return
6351           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6352                                                   /*template_only=*/true,
6353                                                   args, access_path);
6354       }
6355
6356     case OVERLOAD:
6357     case FUNCTION_DECL:
6358       return
6359         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6360                                                 /*template_only=*/false,
6361                                                 /*explicit_targs=*/NULL_TREE,
6362                                                 access_path);
6363
6364     case COMPOUND_EXPR:
6365       TREE_OPERAND (rhs, 0)
6366         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6367       if (TREE_OPERAND (rhs, 0) == error_mark_node)
6368         return error_mark_node;
6369       TREE_OPERAND (rhs, 1)
6370         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6371       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6372         return error_mark_node;
6373
6374       TREE_TYPE (rhs) = lhstype;
6375       return rhs;
6376
6377     case ADDR_EXPR:
6378     {
6379       if (PTRMEM_OK_P (rhs))
6380         flags |= tf_ptrmem_ok;
6381
6382       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6383     }
6384
6385     case ERROR_MARK:
6386       return error_mark_node;
6387
6388     default:
6389       gcc_unreachable ();
6390     }
6391   return error_mark_node;
6392 }
6393 \f
6394 /* Return the name of the virtual function pointer field
6395    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6396    this may have to look back through base types to find the
6397    ultimate field name.  (For single inheritance, these could
6398    all be the same name.  Who knows for multiple inheritance).  */
6399
6400 static tree
6401 get_vfield_name (tree type)
6402 {
6403   tree binfo, base_binfo;
6404   char *buf;
6405
6406   for (binfo = TYPE_BINFO (type);
6407        BINFO_N_BASE_BINFOS (binfo);
6408        binfo = base_binfo)
6409     {
6410       base_binfo = BINFO_BASE_BINFO (binfo, 0);
6411
6412       if (BINFO_VIRTUAL_P (base_binfo)
6413           || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6414         break;
6415     }
6416
6417   type = BINFO_TYPE (binfo);
6418   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6419                          + TYPE_NAME_LENGTH (type) + 2);
6420   sprintf (buf, VFIELD_NAME_FORMAT,
6421            IDENTIFIER_POINTER (constructor_name (type)));
6422   return get_identifier (buf);
6423 }
6424
6425 void
6426 print_class_statistics (void)
6427 {
6428 #ifdef GATHER_STATISTICS
6429   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6430   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6431   if (n_vtables)
6432     {
6433       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6434                n_vtables, n_vtable_searches);
6435       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6436                n_vtable_entries, n_vtable_elems);
6437     }
6438 #endif
6439 }
6440
6441 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6442    according to [class]:
6443                                           The class-name is also inserted
6444    into  the scope of the class itself.  For purposes of access checking,
6445    the inserted class name is treated as if it were a public member name.  */
6446
6447 void
6448 build_self_reference (void)
6449 {
6450   tree name = constructor_name (current_class_type);
6451   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6452   tree saved_cas;
6453
6454   DECL_NONLOCAL (value) = 1;
6455   DECL_CONTEXT (value) = current_class_type;
6456   DECL_ARTIFICIAL (value) = 1;
6457   SET_DECL_SELF_REFERENCE_P (value);
6458
6459   if (processing_template_decl)
6460     value = push_template_decl (value);
6461
6462   saved_cas = current_access_specifier;
6463   current_access_specifier = access_public_node;
6464   finish_member_declaration (value);
6465   current_access_specifier = saved_cas;
6466 }
6467
6468 /* Returns 1 if TYPE contains only padding bytes.  */
6469
6470 int
6471 is_empty_class (tree type)
6472 {
6473   if (type == error_mark_node)
6474     return 0;
6475
6476   if (! CLASS_TYPE_P (type))
6477     return 0;
6478
6479   /* In G++ 3.2, whether or not a class was empty was determined by
6480      looking at its size.  */
6481   if (abi_version_at_least (2))
6482     return CLASSTYPE_EMPTY_P (type);
6483   else
6484     return integer_zerop (CLASSTYPE_SIZE (type));
6485 }
6486
6487 /* Returns true if TYPE contains an empty class.  */
6488
6489 static bool
6490 contains_empty_class_p (tree type)
6491 {
6492   if (is_empty_class (type))
6493     return true;
6494   if (CLASS_TYPE_P (type))
6495     {
6496       tree field;
6497       tree binfo;
6498       tree base_binfo;
6499       int i;
6500
6501       for (binfo = TYPE_BINFO (type), i = 0;
6502            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6503         if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6504           return true;
6505       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6506         if (TREE_CODE (field) == FIELD_DECL
6507             && !DECL_ARTIFICIAL (field)
6508             && is_empty_class (TREE_TYPE (field)))
6509           return true;
6510     }
6511   else if (TREE_CODE (type) == ARRAY_TYPE)
6512     return contains_empty_class_p (TREE_TYPE (type));
6513   return false;
6514 }
6515
6516 /* Returns true if TYPE contains no actual data, just various
6517    possible combinations of empty classes.  */
6518
6519 bool
6520 is_really_empty_class (tree type)
6521 {
6522   if (is_empty_class (type))
6523     return true;
6524   if (CLASS_TYPE_P (type))
6525     {
6526       tree field;
6527       tree binfo;
6528       tree base_binfo;
6529       int i;
6530
6531       for (binfo = TYPE_BINFO (type), i = 0;
6532            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6533         if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
6534           return false;
6535       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6536         if (TREE_CODE (field) == FIELD_DECL
6537             && !DECL_ARTIFICIAL (field)
6538             && !is_really_empty_class (TREE_TYPE (field)))
6539           return false;
6540       return true;
6541     }
6542   else if (TREE_CODE (type) == ARRAY_TYPE)
6543     return is_really_empty_class (TREE_TYPE (type));
6544   return false;
6545 }
6546
6547 /* Note that NAME was looked up while the current class was being
6548    defined and that the result of that lookup was DECL.  */
6549
6550 void
6551 maybe_note_name_used_in_class (tree name, tree decl)
6552 {
6553   splay_tree names_used;
6554
6555   /* If we're not defining a class, there's nothing to do.  */
6556   if (!(innermost_scope_kind() == sk_class
6557         && TYPE_BEING_DEFINED (current_class_type)))
6558     return;
6559
6560   /* If there's already a binding for this NAME, then we don't have
6561      anything to worry about.  */
6562   if (lookup_member (current_class_type, name,
6563                      /*protect=*/0, /*want_type=*/false))
6564     return;
6565
6566   if (!current_class_stack[current_class_depth - 1].names_used)
6567     current_class_stack[current_class_depth - 1].names_used
6568       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6569   names_used = current_class_stack[current_class_depth - 1].names_used;
6570
6571   splay_tree_insert (names_used,
6572                      (splay_tree_key) name,
6573                      (splay_tree_value) decl);
6574 }
6575
6576 /* Note that NAME was declared (as DECL) in the current class.  Check
6577    to see that the declaration is valid.  */
6578
6579 void
6580 note_name_declared_in_class (tree name, tree decl)
6581 {
6582   splay_tree names_used;
6583   splay_tree_node n;
6584
6585   /* Look to see if we ever used this name.  */
6586   names_used
6587     = current_class_stack[current_class_depth - 1].names_used;
6588   if (!names_used)
6589     return;
6590
6591   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6592   if (n)
6593     {
6594       /* [basic.scope.class]
6595
6596          A name N used in a class S shall refer to the same declaration
6597          in its context and when re-evaluated in the completed scope of
6598          S.  */
6599       permerror (input_location, "declaration of %q#D", decl);
6600       permerror (input_location, "changes meaning of %qD from %q+#D",
6601                DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
6602     }
6603 }
6604
6605 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6606    Secondary vtables are merged with primary vtables; this function
6607    will return the VAR_DECL for the primary vtable.  */
6608
6609 tree
6610 get_vtbl_decl_for_binfo (tree binfo)
6611 {
6612   tree decl;
6613
6614   decl = BINFO_VTABLE (binfo);
6615   if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR)
6616     {
6617       gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6618       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6619     }
6620   if (decl)
6621     gcc_assert (TREE_CODE (decl) == VAR_DECL);
6622   return decl;
6623 }
6624
6625
6626 /* Returns the binfo for the primary base of BINFO.  If the resulting
6627    BINFO is a virtual base, and it is inherited elsewhere in the
6628    hierarchy, then the returned binfo might not be the primary base of
6629    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6630    BINFO_LOST_PRIMARY_P to be sure.  */
6631
6632 static tree
6633 get_primary_binfo (tree binfo)
6634 {
6635   tree primary_base;
6636
6637   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6638   if (!primary_base)
6639     return NULL_TREE;
6640
6641   return copied_binfo (primary_base, binfo);
6642 }
6643
6644 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6645
6646 static int
6647 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6648 {
6649   if (!indented_p)
6650     fprintf (stream, "%*s", indent, "");
6651   return 1;
6652 }
6653
6654 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6655    INDENT should be zero when called from the top level; it is
6656    incremented recursively.  IGO indicates the next expected BINFO in
6657    inheritance graph ordering.  */
6658
6659 static tree
6660 dump_class_hierarchy_r (FILE *stream,
6661                         int flags,
6662                         tree binfo,
6663                         tree igo,
6664                         int indent)
6665 {
6666   int indented = 0;
6667   tree base_binfo;
6668   int i;
6669
6670   indented = maybe_indent_hierarchy (stream, indent, 0);
6671   fprintf (stream, "%s (0x%lx) ",
6672            type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6673            (unsigned long) binfo);
6674   if (binfo != igo)
6675     {
6676       fprintf (stream, "alternative-path\n");
6677       return igo;
6678     }
6679   igo = TREE_CHAIN (binfo);
6680
6681   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6682            tree_low_cst (BINFO_OFFSET (binfo), 0));
6683   if (is_empty_class (BINFO_TYPE (binfo)))
6684     fprintf (stream, " empty");
6685   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6686     fprintf (stream, " nearly-empty");
6687   if (BINFO_VIRTUAL_P (binfo))
6688     fprintf (stream, " virtual");
6689   fprintf (stream, "\n");
6690
6691   indented = 0;
6692   if (BINFO_PRIMARY_P (binfo))
6693     {
6694       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6695       fprintf (stream, " primary-for %s (0x%lx)",
6696                type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
6697                                TFF_PLAIN_IDENTIFIER),
6698                (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
6699     }
6700   if (BINFO_LOST_PRIMARY_P (binfo))
6701     {
6702       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6703       fprintf (stream, " lost-primary");
6704     }
6705   if (indented)
6706     fprintf (stream, "\n");
6707
6708   if (!(flags & TDF_SLIM))
6709     {
6710       int indented = 0;
6711
6712       if (BINFO_SUBVTT_INDEX (binfo))
6713         {
6714           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6715           fprintf (stream, " subvttidx=%s",
6716                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6717                                    TFF_PLAIN_IDENTIFIER));
6718         }
6719       if (BINFO_VPTR_INDEX (binfo))
6720         {
6721           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6722           fprintf (stream, " vptridx=%s",
6723                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6724                                    TFF_PLAIN_IDENTIFIER));
6725         }
6726       if (BINFO_VPTR_FIELD (binfo))
6727         {
6728           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6729           fprintf (stream, " vbaseoffset=%s",
6730                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6731                                    TFF_PLAIN_IDENTIFIER));
6732         }
6733       if (BINFO_VTABLE (binfo))
6734         {
6735           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6736           fprintf (stream, " vptr=%s",
6737                    expr_as_string (BINFO_VTABLE (binfo),
6738                                    TFF_PLAIN_IDENTIFIER));
6739         }
6740
6741       if (indented)
6742         fprintf (stream, "\n");
6743     }
6744
6745   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
6746     igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
6747
6748   return igo;
6749 }
6750
6751 /* Dump the BINFO hierarchy for T.  */
6752
6753 static void
6754 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6755 {
6756   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6757   fprintf (stream, "   size=%lu align=%lu\n",
6758            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6759            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6760   fprintf (stream, "   base size=%lu base align=%lu\n",
6761            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6762                            / BITS_PER_UNIT),
6763            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6764                            / BITS_PER_UNIT));
6765   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6766   fprintf (stream, "\n");
6767 }
6768
6769 /* Debug interface to hierarchy dumping.  */
6770
6771 void
6772 debug_class (tree t)
6773 {
6774   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6775 }
6776
6777 static void
6778 dump_class_hierarchy (tree t)
6779 {
6780   int flags;
6781   FILE *stream = dump_begin (TDI_class, &flags);
6782
6783   if (stream)
6784     {
6785       dump_class_hierarchy_1 (stream, flags, t);
6786       dump_end (TDI_class, stream);
6787     }
6788 }
6789
6790 static void
6791 dump_array (FILE * stream, tree decl)
6792 {
6793   tree value;
6794   unsigned HOST_WIDE_INT ix;
6795   HOST_WIDE_INT elt;
6796   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6797
6798   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6799          / BITS_PER_UNIT);
6800   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6801   fprintf (stream, " %s entries",
6802            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6803                            TFF_PLAIN_IDENTIFIER));
6804   fprintf (stream, "\n");
6805
6806   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
6807                               ix, value)
6808     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6809              expr_as_string (value, TFF_PLAIN_IDENTIFIER));
6810 }
6811
6812 static void
6813 dump_vtable (tree t, tree binfo, tree vtable)
6814 {
6815   int flags;
6816   FILE *stream = dump_begin (TDI_class, &flags);
6817
6818   if (!stream)
6819     return;
6820
6821   if (!(flags & TDF_SLIM))
6822     {
6823       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6824
6825       fprintf (stream, "%s for %s",
6826                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6827                type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
6828       if (ctor_vtbl_p)
6829         {
6830           if (!BINFO_VIRTUAL_P (binfo))
6831             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6832           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6833         }
6834       fprintf (stream, "\n");
6835       dump_array (stream, vtable);
6836       fprintf (stream, "\n");
6837     }
6838
6839   dump_end (TDI_class, stream);
6840 }
6841
6842 static void
6843 dump_vtt (tree t, tree vtt)
6844 {
6845   int flags;
6846   FILE *stream = dump_begin (TDI_class, &flags);
6847
6848   if (!stream)
6849     return;
6850
6851   if (!(flags & TDF_SLIM))
6852     {
6853       fprintf (stream, "VTT for %s\n",
6854                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6855       dump_array (stream, vtt);
6856       fprintf (stream, "\n");
6857     }
6858
6859   dump_end (TDI_class, stream);
6860 }
6861
6862 /* Dump a function or thunk and its thunkees.  */
6863
6864 static void
6865 dump_thunk (FILE *stream, int indent, tree thunk)
6866 {
6867   static const char spaces[] = "        ";
6868   tree name = DECL_NAME (thunk);
6869   tree thunks;
6870
6871   fprintf (stream, "%.*s%p %s %s", indent, spaces,
6872            (void *)thunk,
6873            !DECL_THUNK_P (thunk) ? "function"
6874            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6875            name ? IDENTIFIER_POINTER (name) : "<unset>");
6876   if (DECL_THUNK_P (thunk))
6877     {
6878       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6879       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6880
6881       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6882       if (!virtual_adjust)
6883         /*NOP*/;
6884       else if (DECL_THIS_THUNK_P (thunk))
6885         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
6886                  tree_low_cst (virtual_adjust, 0));
6887       else
6888         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6889                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6890                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6891       if (THUNK_ALIAS (thunk))
6892         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6893     }
6894   fprintf (stream, "\n");
6895   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6896     dump_thunk (stream, indent + 2, thunks);
6897 }
6898
6899 /* Dump the thunks for FN.  */
6900
6901 void
6902 debug_thunks (tree fn)
6903 {
6904   dump_thunk (stderr, 0, fn);
6905 }
6906
6907 /* Virtual function table initialization.  */
6908
6909 /* Create all the necessary vtables for T and its base classes.  */
6910
6911 static void
6912 finish_vtbls (tree t)
6913 {
6914   tree list;
6915   tree vbase;
6916
6917   /* We lay out the primary and secondary vtables in one contiguous
6918      vtable.  The primary vtable is first, followed by the non-virtual
6919      secondary vtables in inheritance graph order.  */
6920   list = build_tree_list (BINFO_VTABLE (TYPE_BINFO (t)), NULL_TREE);
6921   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6922                          TYPE_BINFO (t), t, list);
6923
6924   /* Then come the virtual bases, also in inheritance graph order.  */
6925   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6926     {
6927       if (!BINFO_VIRTUAL_P (vbase))
6928         continue;
6929       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6930     }
6931
6932   if (BINFO_VTABLE (TYPE_BINFO (t)))
6933     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6934 }
6935
6936 /* Initialize the vtable for BINFO with the INITS.  */
6937
6938 static void
6939 initialize_vtable (tree binfo, tree inits)
6940 {
6941   tree decl;
6942
6943   layout_vtable_decl (binfo, list_length (inits));
6944   decl = get_vtbl_decl_for_binfo (binfo);
6945   initialize_artificial_var (decl, inits);
6946   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6947 }
6948
6949 /* Build the VTT (virtual table table) for T.
6950    A class requires a VTT if it has virtual bases.
6951
6952    This holds
6953    1 - primary virtual pointer for complete object T
6954    2 - secondary VTTs for each direct non-virtual base of T which requires a
6955        VTT
6956    3 - secondary virtual pointers for each direct or indirect base of T which
6957        has virtual bases or is reachable via a virtual path from T.
6958    4 - secondary VTTs for each direct or indirect virtual base of T.
6959
6960    Secondary VTTs look like complete object VTTs without part 4.  */
6961
6962 static void
6963 build_vtt (tree t)
6964 {
6965   tree inits;
6966   tree type;
6967   tree vtt;
6968   tree index;
6969
6970   /* Build up the initializers for the VTT.  */
6971   inits = NULL_TREE;
6972   index = size_zero_node;
6973   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6974
6975   /* If we didn't need a VTT, we're done.  */
6976   if (!inits)
6977     return;
6978
6979   /* Figure out the type of the VTT.  */
6980   type = build_index_type (size_int (list_length (inits) - 1));
6981   type = build_cplus_array_type (const_ptr_type_node, type);
6982
6983   /* Now, build the VTT object itself.  */
6984   vtt = build_vtable (t, mangle_vtt_for_type (t), type);
6985   initialize_artificial_var (vtt, inits);
6986   /* Add the VTT to the vtables list.  */
6987   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6988   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6989
6990   dump_vtt (t, vtt);
6991 }
6992
6993 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6994    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6995    and CHAIN the vtable pointer for this binfo after construction is
6996    complete.  VALUE can also be another BINFO, in which case we recurse.  */
6997
6998 static tree
6999 binfo_ctor_vtable (tree binfo)
7000 {
7001   tree vt;
7002
7003   while (1)
7004     {
7005       vt = BINFO_VTABLE (binfo);
7006       if (TREE_CODE (vt) == TREE_LIST)
7007         vt = TREE_VALUE (vt);
7008       if (TREE_CODE (vt) == TREE_BINFO)
7009         binfo = vt;
7010       else
7011         break;
7012     }
7013
7014   return vt;
7015 }
7016
7017 /* Data for secondary VTT initialization.  */
7018 typedef struct secondary_vptr_vtt_init_data_s
7019 {
7020   /* Is this the primary VTT? */
7021   bool top_level_p;
7022
7023   /* Current index into the VTT.  */
7024   tree index;
7025
7026   /* TREE_LIST of initializers built up.  */
7027   tree inits;
7028
7029   /* The type being constructed by this secondary VTT.  */
7030   tree type_being_constructed;
7031 } secondary_vptr_vtt_init_data;
7032
7033 /* Recursively build the VTT-initializer for BINFO (which is in the
7034    hierarchy dominated by T).  INITS points to the end of the initializer
7035    list to date.  INDEX is the VTT index where the next element will be
7036    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7037    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
7038    for virtual bases of T. When it is not so, we build the constructor
7039    vtables for the BINFO-in-T variant.  */
7040
7041 static tree *
7042 build_vtt_inits (tree binfo, tree t, tree *inits, tree *index)
7043 {
7044   int i;
7045   tree b;
7046   tree init;
7047   tree secondary_vptrs;
7048   secondary_vptr_vtt_init_data data;
7049   int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7050
7051   /* We only need VTTs for subobjects with virtual bases.  */
7052   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7053     return inits;
7054
7055   /* We need to use a construction vtable if this is not the primary
7056      VTT.  */
7057   if (!top_level_p)
7058     {
7059       build_ctor_vtbl_group (binfo, t);
7060
7061       /* Record the offset in the VTT where this sub-VTT can be found.  */
7062       BINFO_SUBVTT_INDEX (binfo) = *index;
7063     }
7064
7065   /* Add the address of the primary vtable for the complete object.  */
7066   init = binfo_ctor_vtable (binfo);
7067   *inits = build_tree_list (NULL_TREE, init);
7068   inits = &TREE_CHAIN (*inits);
7069   if (top_level_p)
7070     {
7071       gcc_assert (!BINFO_VPTR_INDEX (binfo));
7072       BINFO_VPTR_INDEX (binfo) = *index;
7073     }
7074   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
7075
7076   /* Recursively add the secondary VTTs for non-virtual bases.  */
7077   for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
7078     if (!BINFO_VIRTUAL_P (b))
7079       inits = build_vtt_inits (b, t, inits, index);
7080
7081   /* Add secondary virtual pointers for all subobjects of BINFO with
7082      either virtual bases or reachable along a virtual path, except
7083      subobjects that are non-virtual primary bases.  */
7084   data.top_level_p = top_level_p;
7085   data.index = *index;
7086   data.inits = NULL;
7087   data.type_being_constructed = BINFO_TYPE (binfo);
7088
7089   dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
7090
7091   *index = data.index;
7092
7093   /* The secondary vptrs come back in reverse order.  After we reverse
7094      them, and add the INITS, the last init will be the first element
7095      of the chain.  */
7096   secondary_vptrs = data.inits;
7097   if (secondary_vptrs)
7098     {
7099       *inits = nreverse (secondary_vptrs);
7100       inits = &TREE_CHAIN (secondary_vptrs);
7101       gcc_assert (*inits == NULL_TREE);
7102     }
7103
7104   if (top_level_p)
7105     /* Add the secondary VTTs for virtual bases in inheritance graph
7106        order.  */
7107     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
7108       {
7109         if (!BINFO_VIRTUAL_P (b))
7110           continue;
7111
7112         inits = build_vtt_inits (b, t, inits, index);
7113       }
7114   else
7115     /* Remove the ctor vtables we created.  */
7116     dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
7117
7118   return inits;
7119 }
7120
7121 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo for the base
7122    in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure.  */
7123
7124 static tree
7125 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
7126 {
7127   secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
7128
7129   /* We don't care about bases that don't have vtables.  */
7130   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7131     return dfs_skip_bases;
7132
7133   /* We're only interested in proper subobjects of the type being
7134      constructed.  */
7135   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
7136     return NULL_TREE;
7137
7138   /* We're only interested in bases with virtual bases or reachable
7139      via a virtual path from the type being constructed.  */
7140   if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7141         || binfo_via_virtual (binfo, data->type_being_constructed)))
7142     return dfs_skip_bases;
7143
7144   /* We're not interested in non-virtual primary bases.  */
7145   if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
7146     return NULL_TREE;
7147
7148   /* Record the index where this secondary vptr can be found.  */
7149   if (data->top_level_p)
7150     {
7151       gcc_assert (!BINFO_VPTR_INDEX (binfo));
7152       BINFO_VPTR_INDEX (binfo) = data->index;
7153
7154       if (BINFO_VIRTUAL_P (binfo))
7155         {
7156           /* It's a primary virtual base, and this is not a
7157              construction vtable.  Find the base this is primary of in
7158              the inheritance graph, and use that base's vtable
7159              now.  */
7160           while (BINFO_PRIMARY_P (binfo))
7161             binfo = BINFO_INHERITANCE_CHAIN (binfo);
7162         }
7163     }
7164
7165   /* Add the initializer for the secondary vptr itself.  */
7166   data->inits = tree_cons (NULL_TREE, binfo_ctor_vtable (binfo), data->inits);
7167
7168   /* Advance the vtt index.  */
7169   data->index = size_binop (PLUS_EXPR, data->index,
7170                             TYPE_SIZE_UNIT (ptr_type_node));
7171
7172   return NULL_TREE;
7173 }
7174
7175 /* Called from build_vtt_inits via dfs_walk. After building
7176    constructor vtables and generating the sub-vtt from them, we need
7177    to restore the BINFO_VTABLES that were scribbled on.  DATA is the
7178    binfo of the base whose sub vtt was generated.  */
7179
7180 static tree
7181 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7182 {
7183   tree vtable = BINFO_VTABLE (binfo);
7184
7185   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7186     /* If this class has no vtable, none of its bases do.  */
7187     return dfs_skip_bases;
7188
7189   if (!vtable)
7190     /* This might be a primary base, so have no vtable in this
7191        hierarchy.  */
7192     return NULL_TREE;
7193
7194   /* If we scribbled the construction vtable vptr into BINFO, clear it
7195      out now.  */
7196   if (TREE_CODE (vtable) == TREE_LIST
7197       && (TREE_PURPOSE (vtable) == (tree) data))
7198     BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
7199
7200   return NULL_TREE;
7201 }
7202
7203 /* Build the construction vtable group for BINFO which is in the
7204    hierarchy dominated by T.  */
7205
7206 static void
7207 build_ctor_vtbl_group (tree binfo, tree t)
7208 {
7209   tree list;
7210   tree type;
7211   tree vtbl;
7212   tree inits;
7213   tree id;
7214   tree vbase;
7215
7216   /* See if we've already created this construction vtable group.  */
7217   id = mangle_ctor_vtbl_for_type (t, binfo);
7218   if (IDENTIFIER_GLOBAL_VALUE (id))
7219     return;
7220
7221   gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
7222   /* Build a version of VTBL (with the wrong type) for use in
7223      constructing the addresses of secondary vtables in the
7224      construction vtable group.  */
7225   vtbl = build_vtable (t, id, ptr_type_node);
7226   DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
7227   list = build_tree_list (vtbl, NULL_TREE);
7228   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7229                          binfo, t, list);
7230
7231   /* Add the vtables for each of our virtual bases using the vbase in T
7232      binfo.  */
7233   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7234        vbase;
7235        vbase = TREE_CHAIN (vbase))
7236     {
7237       tree b;
7238
7239       if (!BINFO_VIRTUAL_P (vbase))
7240         continue;
7241       b = copied_binfo (vbase, binfo);
7242
7243       accumulate_vtbl_inits (b, vbase, binfo, t, list);
7244     }
7245   inits = TREE_VALUE (list);
7246
7247   /* Figure out the type of the construction vtable.  */
7248   type = build_index_type (size_int (list_length (inits) - 1));
7249   type = build_cplus_array_type (vtable_entry_type, type);
7250   layout_type (type);
7251   TREE_TYPE (vtbl) = type;
7252   DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE;
7253   layout_decl (vtbl, 0);
7254
7255   /* Initialize the construction vtable.  */
7256   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7257   initialize_artificial_var (vtbl, inits);
7258   dump_vtable (t, binfo, vtbl);
7259 }
7260
7261 /* Add the vtbl initializers for BINFO (and its bases other than
7262    non-virtual primaries) to the list of INITS.  BINFO is in the
7263    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
7264    the constructor the vtbl inits should be accumulated for. (If this
7265    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7266    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7267    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7268    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7269    but are not necessarily the same in terms of layout.  */
7270
7271 static void
7272 accumulate_vtbl_inits (tree binfo,
7273                        tree orig_binfo,
7274                        tree rtti_binfo,
7275                        tree t,
7276                        tree inits)
7277 {
7278   int i;
7279   tree base_binfo;
7280   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7281
7282   gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
7283
7284   /* If it doesn't have a vptr, we don't do anything.  */
7285   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7286     return;
7287
7288   /* If we're building a construction vtable, we're not interested in
7289      subobjects that don't require construction vtables.  */
7290   if (ctor_vtbl_p
7291       && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7292       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7293     return;
7294
7295   /* Build the initializers for the BINFO-in-T vtable.  */
7296   TREE_VALUE (inits)
7297     = chainon (TREE_VALUE (inits),
7298                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7299                                           rtti_binfo, t, inits));
7300
7301   /* Walk the BINFO and its bases.  We walk in preorder so that as we
7302      initialize each vtable we can figure out at what offset the
7303      secondary vtable lies from the primary vtable.  We can't use
7304      dfs_walk here because we need to iterate through bases of BINFO
7305      and RTTI_BINFO simultaneously.  */
7306   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7307     {
7308       /* Skip virtual bases.  */
7309       if (BINFO_VIRTUAL_P (base_binfo))
7310         continue;
7311       accumulate_vtbl_inits (base_binfo,
7312                              BINFO_BASE_BINFO (orig_binfo, i),
7313                              rtti_binfo, t,
7314                              inits);
7315     }
7316 }
7317
7318 /* Called from accumulate_vtbl_inits.  Returns the initializers for
7319    the BINFO vtable.  */
7320
7321 static tree
7322 dfs_accumulate_vtbl_inits (tree binfo,
7323                            tree orig_binfo,
7324                            tree rtti_binfo,
7325                            tree t,
7326                            tree l)
7327 {
7328   tree inits = NULL_TREE;
7329   tree vtbl = NULL_TREE;
7330   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7331
7332   if (ctor_vtbl_p
7333       && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7334     {
7335       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7336          primary virtual base.  If it is not the same primary in
7337          the hierarchy of T, we'll need to generate a ctor vtable
7338          for it, to place at its location in T.  If it is the same
7339          primary, we still need a VTT entry for the vtable, but it
7340          should point to the ctor vtable for the base it is a
7341          primary for within the sub-hierarchy of RTTI_BINFO.
7342
7343          There are three possible cases:
7344
7345          1) We are in the same place.
7346          2) We are a primary base within a lost primary virtual base of
7347          RTTI_BINFO.
7348          3) We are primary to something not a base of RTTI_BINFO.  */
7349
7350       tree b;
7351       tree last = NULL_TREE;
7352
7353       /* First, look through the bases we are primary to for RTTI_BINFO
7354          or a virtual base.  */
7355       b = binfo;
7356       while (BINFO_PRIMARY_P (b))
7357         {
7358           b = BINFO_INHERITANCE_CHAIN (b);
7359           last = b;
7360           if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7361             goto found;
7362         }
7363       /* If we run out of primary links, keep looking down our
7364          inheritance chain; we might be an indirect primary.  */
7365       for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7366         if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7367           break;
7368     found:
7369
7370       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7371          base B and it is a base of RTTI_BINFO, this is case 2.  In
7372          either case, we share our vtable with LAST, i.e. the
7373          derived-most base within B of which we are a primary.  */
7374       if (b == rtti_binfo
7375           || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7376         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7377            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7378            binfo_ctor_vtable after everything's been set up.  */
7379         vtbl = last;
7380
7381       /* Otherwise, this is case 3 and we get our own.  */
7382     }
7383   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7384     return inits;
7385
7386   if (!vtbl)
7387     {
7388       tree index;
7389       int non_fn_entries;
7390
7391       /* Compute the initializer for this vtable.  */
7392       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7393                                       &non_fn_entries);
7394
7395       /* Figure out the position to which the VPTR should point.  */
7396       vtbl = TREE_PURPOSE (l);
7397       vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, vtbl);
7398       index = size_binop (PLUS_EXPR,
7399                           size_int (non_fn_entries),
7400                           size_int (list_length (TREE_VALUE (l))));
7401       index = size_binop (MULT_EXPR,
7402                           TYPE_SIZE_UNIT (vtable_entry_type),
7403                           index);
7404       vtbl = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7405     }
7406
7407   if (ctor_vtbl_p)
7408     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7409        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7410        straighten this out.  */
7411     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7412   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7413     inits = NULL_TREE;
7414   else
7415      /* For an ordinary vtable, set BINFO_VTABLE.  */
7416     BINFO_VTABLE (binfo) = vtbl;
7417
7418   return inits;
7419 }
7420
7421 static GTY(()) tree abort_fndecl_addr;
7422
7423 /* Construct the initializer for BINFO's virtual function table.  BINFO
7424    is part of the hierarchy dominated by T.  If we're building a
7425    construction vtable, the ORIG_BINFO is the binfo we should use to
7426    find the actual function pointers to put in the vtable - but they
7427    can be overridden on the path to most-derived in the graph that
7428    ORIG_BINFO belongs.  Otherwise,
7429    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7430    BINFO that should be indicated by the RTTI information in the
7431    vtable; it will be a base class of T, rather than T itself, if we
7432    are building a construction vtable.
7433
7434    The value returned is a TREE_LIST suitable for wrapping in a
7435    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7436    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7437    number of non-function entries in the vtable.
7438
7439    It might seem that this function should never be called with a
7440    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7441    base is always subsumed by a derived class vtable.  However, when
7442    we are building construction vtables, we do build vtables for
7443    primary bases; we need these while the primary base is being
7444    constructed.  */
7445
7446 static tree
7447 build_vtbl_initializer (tree binfo,
7448                         tree orig_binfo,
7449                         tree t,
7450                         tree rtti_binfo,
7451                         int* non_fn_entries_p)
7452 {
7453   tree v, b;
7454   tree vfun_inits;
7455   vtbl_init_data vid;
7456   unsigned ix;
7457   tree vbinfo;
7458   VEC(tree,gc) *vbases;
7459
7460   /* Initialize VID.  */
7461   memset (&vid, 0, sizeof (vid));
7462   vid.binfo = binfo;
7463   vid.derived = t;
7464   vid.rtti_binfo = rtti_binfo;
7465   vid.last_init = &vid.inits;
7466   vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7467   vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7468   vid.generate_vcall_entries = true;
7469   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7470   vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7471
7472   /* Add entries to the vtable for RTTI.  */
7473   build_rtti_vtbl_entries (binfo, &vid);
7474
7475   /* Create an array for keeping track of the functions we've
7476      processed.  When we see multiple functions with the same
7477      signature, we share the vcall offsets.  */
7478   vid.fns = VEC_alloc (tree, gc, 32);
7479   /* Add the vcall and vbase offset entries.  */
7480   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7481
7482   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7483      build_vbase_offset_vtbl_entries.  */
7484   for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7485        VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7486     BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7487
7488   /* If the target requires padding between data entries, add that now.  */
7489   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7490     {
7491       tree cur, *prev;
7492
7493       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7494         {
7495           tree add = cur;
7496           int i;
7497
7498           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7499             add = tree_cons (NULL_TREE,
7500                              build1 (NOP_EXPR, vtable_entry_type,
7501                                      null_pointer_node),
7502                              add);
7503           *prev = add;
7504         }
7505     }
7506
7507   if (non_fn_entries_p)
7508     *non_fn_entries_p = list_length (vid.inits);
7509
7510   /* Go through all the ordinary virtual functions, building up
7511      initializers.  */
7512   vfun_inits = NULL_TREE;
7513   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7514     {
7515       tree delta;
7516       tree vcall_index;
7517       tree fn, fn_original;
7518       tree init = NULL_TREE;
7519
7520       fn = BV_FN (v);
7521       fn_original = fn;
7522       if (DECL_THUNK_P (fn))
7523         {
7524           if (!DECL_NAME (fn))
7525             finish_thunk (fn);
7526           if (THUNK_ALIAS (fn))
7527             {
7528               fn = THUNK_ALIAS (fn);
7529               BV_FN (v) = fn;
7530             }
7531           fn_original = THUNK_TARGET (fn);
7532         }
7533
7534       /* If the only definition of this function signature along our
7535          primary base chain is from a lost primary, this vtable slot will
7536          never be used, so just zero it out.  This is important to avoid
7537          requiring extra thunks which cannot be generated with the function.
7538
7539          We first check this in update_vtable_entry_for_fn, so we handle
7540          restored primary bases properly; we also need to do it here so we
7541          zero out unused slots in ctor vtables, rather than filling them
7542          with erroneous values (though harmless, apart from relocation
7543          costs).  */
7544       for (b = binfo; ; b = get_primary_binfo (b))
7545         {
7546           /* We found a defn before a lost primary; go ahead as normal.  */
7547           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7548             break;
7549
7550           /* The nearest definition is from a lost primary; clear the
7551              slot.  */
7552           if (BINFO_LOST_PRIMARY_P (b))
7553             {
7554               init = size_zero_node;
7555               break;
7556             }
7557         }
7558
7559       if (! init)
7560         {
7561           /* Pull the offset for `this', and the function to call, out of
7562              the list.  */
7563           delta = BV_DELTA (v);
7564           vcall_index = BV_VCALL_INDEX (v);
7565
7566           gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7567           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7568
7569           /* You can't call an abstract virtual function; it's abstract.
7570              So, we replace these functions with __pure_virtual.  */
7571           if (DECL_PURE_VIRTUAL_P (fn_original))
7572             {
7573               fn = abort_fndecl;
7574               if (abort_fndecl_addr == NULL)
7575                 abort_fndecl_addr = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7576               init = abort_fndecl_addr;
7577             }
7578           else
7579             {
7580               if (!integer_zerop (delta) || vcall_index)
7581                 {
7582                   fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7583                   if (!DECL_NAME (fn))
7584                     finish_thunk (fn);
7585                 }
7586               /* Take the address of the function, considering it to be of an
7587                  appropriate generic type.  */
7588               init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7589             }
7590         }
7591
7592       /* And add it to the chain of initializers.  */
7593       if (TARGET_VTABLE_USES_DESCRIPTORS)
7594         {
7595           int i;
7596           if (init == size_zero_node)
7597             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7598               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7599           else
7600             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7601               {
7602                 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7603                                      TREE_OPERAND (init, 0),
7604                                      build_int_cst (NULL_TREE, i));
7605                 TREE_CONSTANT (fdesc) = 1;
7606
7607                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7608               }
7609         }
7610       else
7611         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7612     }
7613
7614   /* The initializers for virtual functions were built up in reverse
7615      order; straighten them out now.  */
7616   vfun_inits = nreverse (vfun_inits);
7617
7618   /* The negative offset initializers are also in reverse order.  */
7619   vid.inits = nreverse (vid.inits);
7620
7621   /* Chain the two together.  */
7622   return chainon (vid.inits, vfun_inits);
7623 }
7624
7625 /* Adds to vid->inits the initializers for the vbase and vcall
7626    offsets in BINFO, which is in the hierarchy dominated by T.  */
7627
7628 static void
7629 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7630 {
7631   tree b;
7632
7633   /* If this is a derived class, we must first create entries
7634      corresponding to the primary base class.  */
7635   b = get_primary_binfo (binfo);
7636   if (b)
7637     build_vcall_and_vbase_vtbl_entries (b, vid);
7638
7639   /* Add the vbase entries for this base.  */
7640   build_vbase_offset_vtbl_entries (binfo, vid);
7641   /* Add the vcall entries for this base.  */
7642   build_vcall_offset_vtbl_entries (binfo, vid);
7643 }
7644
7645 /* Returns the initializers for the vbase offset entries in the vtable
7646    for BINFO (which is part of the class hierarchy dominated by T), in
7647    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7648    where the next vbase offset will go.  */
7649
7650 static void
7651 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7652 {
7653   tree vbase;
7654   tree t;
7655   tree non_primary_binfo;
7656
7657   /* If there are no virtual baseclasses, then there is nothing to
7658      do.  */
7659   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7660     return;
7661
7662   t = vid->derived;
7663
7664   /* We might be a primary base class.  Go up the inheritance hierarchy
7665      until we find the most derived class of which we are a primary base:
7666      it is the offset of that which we need to use.  */
7667   non_primary_binfo = binfo;
7668   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7669     {
7670       tree b;
7671
7672       /* If we have reached a virtual base, then it must be a primary
7673          base (possibly multi-level) of vid->binfo, or we wouldn't
7674          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7675          might be a lost primary, so just skip down to vid->binfo.  */
7676       if (BINFO_VIRTUAL_P (non_primary_binfo))
7677         {
7678           non_primary_binfo = vid->binfo;
7679           break;
7680         }
7681
7682       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7683       if (get_primary_binfo (b) != non_primary_binfo)
7684         break;
7685       non_primary_binfo = b;
7686     }
7687
7688   /* Go through the virtual bases, adding the offsets.  */
7689   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7690        vbase;
7691        vbase = TREE_CHAIN (vbase))
7692     {
7693       tree b;
7694       tree delta;
7695
7696       if (!BINFO_VIRTUAL_P (vbase))
7697         continue;
7698
7699       /* Find the instance of this virtual base in the complete
7700          object.  */
7701       b = copied_binfo (vbase, binfo);
7702
7703       /* If we've already got an offset for this virtual base, we
7704          don't need another one.  */
7705       if (BINFO_VTABLE_PATH_MARKED (b))
7706         continue;
7707       BINFO_VTABLE_PATH_MARKED (b) = 1;
7708
7709       /* Figure out where we can find this vbase offset.  */
7710       delta = size_binop (MULT_EXPR,
7711                           vid->index,
7712                           convert (ssizetype,
7713                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7714       if (vid->primary_vtbl_p)
7715         BINFO_VPTR_FIELD (b) = delta;
7716
7717       if (binfo != TYPE_BINFO (t))
7718         /* The vbase offset had better be the same.  */
7719         gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
7720
7721       /* The next vbase will come at a more negative offset.  */
7722       vid->index = size_binop (MINUS_EXPR, vid->index,
7723                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7724
7725       /* The initializer is the delta from BINFO to this virtual base.
7726          The vbase offsets go in reverse inheritance-graph order, and
7727          we are walking in inheritance graph order so these end up in
7728          the right order.  */
7729       delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7730
7731       *vid->last_init
7732         = build_tree_list (NULL_TREE,
7733                            fold_build1 (NOP_EXPR,
7734                                         vtable_entry_type,
7735                                         delta));
7736       vid->last_init = &TREE_CHAIN (*vid->last_init);
7737     }
7738 }
7739
7740 /* Adds the initializers for the vcall offset entries in the vtable
7741    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7742    to VID->INITS.  */
7743
7744 static void
7745 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7746 {
7747   /* We only need these entries if this base is a virtual base.  We
7748      compute the indices -- but do not add to the vtable -- when
7749      building the main vtable for a class.  */
7750   if (binfo == TYPE_BINFO (vid->derived)
7751       || (BINFO_VIRTUAL_P (binfo)
7752           /* If BINFO is RTTI_BINFO, then (since BINFO does not
7753              correspond to VID->DERIVED), we are building a primary
7754              construction virtual table.  Since this is a primary
7755              virtual table, we do not need the vcall offsets for
7756              BINFO.  */
7757           && binfo != vid->rtti_binfo))
7758     {
7759       /* We need a vcall offset for each of the virtual functions in this
7760          vtable.  For example:
7761
7762            class A { virtual void f (); };
7763            class B1 : virtual public A { virtual void f (); };
7764            class B2 : virtual public A { virtual void f (); };
7765            class C: public B1, public B2 { virtual void f (); };
7766
7767          A C object has a primary base of B1, which has a primary base of A.  A
7768          C also has a secondary base of B2, which no longer has a primary base
7769          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7770          A, which will adjust the A* to a B2* to call f.  We have no way of
7771          knowing what (or even whether) this offset will be when we define B2,
7772          so we store this "vcall offset" in the A sub-vtable and look it up in
7773          a "virtual thunk" for B2::f.
7774
7775          We need entries for all the functions in our primary vtable and
7776          in our non-virtual bases' secondary vtables.  */
7777       vid->vbase = binfo;
7778       /* If we are just computing the vcall indices -- but do not need
7779          the actual entries -- not that.  */
7780       if (!BINFO_VIRTUAL_P (binfo))
7781         vid->generate_vcall_entries = false;
7782       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7783       add_vcall_offset_vtbl_entries_r (binfo, vid);
7784     }
7785 }
7786
7787 /* Build vcall offsets, starting with those for BINFO.  */
7788
7789 static void
7790 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7791 {
7792   int i;
7793   tree primary_binfo;
7794   tree base_binfo;
7795
7796   /* Don't walk into virtual bases -- except, of course, for the
7797      virtual base for which we are building vcall offsets.  Any
7798      primary virtual base will have already had its offsets generated
7799      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7800   if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
7801     return;
7802
7803   /* If BINFO has a primary base, process it first.  */
7804   primary_binfo = get_primary_binfo (binfo);
7805   if (primary_binfo)
7806     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7807
7808   /* Add BINFO itself to the list.  */
7809   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7810
7811   /* Scan the non-primary bases of BINFO.  */
7812   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7813     if (base_binfo != primary_binfo)
7814       add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7815 }
7816
7817 /* Called from build_vcall_offset_vtbl_entries_r.  */
7818
7819 static void
7820 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7821 {
7822   /* Make entries for the rest of the virtuals.  */
7823   if (abi_version_at_least (2))
7824     {
7825       tree orig_fn;
7826
7827       /* The ABI requires that the methods be processed in declaration
7828          order.  G++ 3.2 used the order in the vtable.  */
7829       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7830            orig_fn;
7831            orig_fn = TREE_CHAIN (orig_fn))
7832         if (DECL_VINDEX (orig_fn))
7833           add_vcall_offset (orig_fn, binfo, vid);
7834     }
7835   else
7836     {
7837       tree derived_virtuals;
7838       tree base_virtuals;
7839       tree orig_virtuals;
7840       /* If BINFO is a primary base, the most derived class which has
7841          BINFO as a primary base; otherwise, just BINFO.  */
7842       tree non_primary_binfo;
7843
7844       /* We might be a primary base class.  Go up the inheritance hierarchy
7845          until we find the most derived class of which we are a primary base:
7846          it is the BINFO_VIRTUALS there that we need to consider.  */
7847       non_primary_binfo = binfo;
7848       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7849         {
7850           tree b;
7851
7852           /* If we have reached a virtual base, then it must be vid->vbase,
7853              because we ignore other virtual bases in
7854              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7855              base (possibly multi-level) of vid->binfo, or we wouldn't
7856              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7857              might be a lost primary, so just skip down to vid->binfo.  */
7858           if (BINFO_VIRTUAL_P (non_primary_binfo))
7859             {
7860               gcc_assert (non_primary_binfo == vid->vbase);
7861               non_primary_binfo = vid->binfo;
7862               break;
7863             }
7864
7865           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7866           if (get_primary_binfo (b) != non_primary_binfo)
7867             break;
7868           non_primary_binfo = b;
7869         }
7870
7871       if (vid->ctor_vtbl_p)
7872         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7873            where rtti_binfo is the most derived type.  */
7874         non_primary_binfo
7875           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7876
7877       for (base_virtuals = BINFO_VIRTUALS (binfo),
7878              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7879              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7880            base_virtuals;
7881            base_virtuals = TREE_CHAIN (base_virtuals),
7882              derived_virtuals = TREE_CHAIN (derived_virtuals),
7883              orig_virtuals = TREE_CHAIN (orig_virtuals))
7884         {
7885           tree orig_fn;
7886
7887           /* Find the declaration that originally caused this function to
7888              be present in BINFO_TYPE (binfo).  */
7889           orig_fn = BV_FN (orig_virtuals);
7890
7891           /* When processing BINFO, we only want to generate vcall slots for
7892              function slots introduced in BINFO.  So don't try to generate
7893              one if the function isn't even defined in BINFO.  */
7894           if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
7895             continue;
7896
7897           add_vcall_offset (orig_fn, binfo, vid);
7898         }
7899     }
7900 }
7901
7902 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7903
7904 static void
7905 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7906 {
7907   size_t i;
7908   tree vcall_offset;
7909   tree derived_entry;
7910
7911   /* If there is already an entry for a function with the same
7912      signature as FN, then we do not need a second vcall offset.
7913      Check the list of functions already present in the derived
7914      class vtable.  */
7915   for (i = 0; VEC_iterate (tree, vid->fns, i, derived_entry); ++i)
7916     {
7917       if (same_signature_p (derived_entry, orig_fn)
7918           /* We only use one vcall offset for virtual destructors,
7919              even though there are two virtual table entries.  */
7920           || (DECL_DESTRUCTOR_P (derived_entry)
7921               && DECL_DESTRUCTOR_P (orig_fn)))
7922         return;
7923     }
7924
7925   /* If we are building these vcall offsets as part of building
7926      the vtable for the most derived class, remember the vcall
7927      offset.  */
7928   if (vid->binfo == TYPE_BINFO (vid->derived))
7929     {
7930       tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
7931                                        CLASSTYPE_VCALL_INDICES (vid->derived),
7932                                        NULL);
7933       elt->purpose = orig_fn;
7934       elt->value = vid->index;
7935     }
7936
7937   /* The next vcall offset will be found at a more negative
7938      offset.  */
7939   vid->index = size_binop (MINUS_EXPR, vid->index,
7940                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7941
7942   /* Keep track of this function.  */
7943   VEC_safe_push (tree, gc, vid->fns, orig_fn);
7944
7945   if (vid->generate_vcall_entries)
7946     {
7947       tree base;
7948       tree fn;
7949
7950       /* Find the overriding function.  */
7951       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7952       if (fn == error_mark_node)
7953         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7954                                integer_zero_node);
7955       else
7956         {
7957           base = TREE_VALUE (fn);
7958
7959           /* The vbase we're working on is a primary base of
7960              vid->binfo.  But it might be a lost primary, so its
7961              BINFO_OFFSET might be wrong, so we just use the
7962              BINFO_OFFSET from vid->binfo.  */
7963           vcall_offset = size_diffop (BINFO_OFFSET (base),
7964                                       BINFO_OFFSET (vid->binfo));
7965           vcall_offset = fold_build1 (NOP_EXPR, vtable_entry_type,
7966                                       vcall_offset);
7967         }
7968       /* Add the initializer to the vtable.  */
7969       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7970       vid->last_init = &TREE_CHAIN (*vid->last_init);
7971     }
7972 }
7973
7974 /* Return vtbl initializers for the RTTI entries corresponding to the
7975    BINFO's vtable.  The RTTI entries should indicate the object given
7976    by VID->rtti_binfo.  */
7977
7978 static void
7979 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7980 {
7981   tree b;
7982   tree t;
7983   tree basetype;
7984   tree offset;
7985   tree decl;
7986   tree init;
7987
7988   basetype = BINFO_TYPE (binfo);
7989   t = BINFO_TYPE (vid->rtti_binfo);
7990
7991   /* To find the complete object, we will first convert to our most
7992      primary base, and then add the offset in the vtbl to that value.  */
7993   b = binfo;
7994   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7995          && !BINFO_LOST_PRIMARY_P (b))
7996     {
7997       tree primary_base;
7998
7999       primary_base = get_primary_binfo (b);
8000       gcc_assert (BINFO_PRIMARY_P (primary_base)
8001                   && BINFO_INHERITANCE_CHAIN (primary_base) == b);
8002       b = primary_base;
8003     }
8004   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
8005
8006   /* The second entry is the address of the typeinfo object.  */
8007   if (flag_rtti)
8008     decl = build_address (get_tinfo_decl (t));
8009   else
8010     decl = integer_zero_node;
8011
8012   /* Convert the declaration to a type that can be stored in the
8013      vtable.  */
8014   init = build_nop (vfunc_ptr_type_node, decl);
8015   *vid->last_init = build_tree_list (NULL_TREE, init);
8016   vid->last_init = &TREE_CHAIN (*vid->last_init);
8017
8018   /* Add the offset-to-top entry.  It comes earlier in the vtable than
8019      the typeinfo entry.  Convert the offset to look like a
8020      function pointer, so that we can put it in the vtable.  */
8021   init = build_nop (vfunc_ptr_type_node, offset);
8022   *vid->last_init = build_tree_list (NULL_TREE, init);
8023   vid->last_init = &TREE_CHAIN (*vid->last_init);
8024 }
8025
8026 /* Fold a OBJ_TYPE_REF expression to the address of a function.
8027    KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF).  */
8028
8029 tree
8030 cp_fold_obj_type_ref (tree ref, tree known_type)
8031 {
8032   HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
8033   HOST_WIDE_INT i = 0;
8034   tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
8035   tree fndecl;
8036
8037   while (i != index)
8038     {
8039       i += (TARGET_VTABLE_USES_DESCRIPTORS
8040             ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
8041       v = TREE_CHAIN (v);
8042     }
8043
8044   fndecl = BV_FN (v);
8045
8046 #ifdef ENABLE_CHECKING
8047   gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
8048                                   DECL_VINDEX (fndecl)));
8049 #endif
8050
8051   cgraph_node (fndecl)->local.vtable_method = true;
8052
8053   return build_address (fndecl);
8054 }
8055
8056 #include "gt-cp-class.h"