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
 629   aref = build_array_ref (vtbl, idx, input_location);
 630   TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx);
 631
 632   return aref;
 633 }
 634
 635 tree
 636 build_vtbl_ref (tree instance, tree idx)
 637 {
 638   tree aref = build_vtbl_ref_1 (instance, idx);
 639
 640   return aref;
 641 }
 642
 643 /* Given a stable object pointer INSTANCE_PTR, return an expression which
 644    yields a function pointer corresponding to vtable element INDEX.  */
 645
 646 tree
 647 build_vfn_ref (tree instance_ptr, tree idx)
 648 {
 649   tree aref;
 650
 651   aref = build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr, 0,
 652                                                   tf_warning_or_error),
 653                            idx);
 654
 655   /* When using function descriptors, the address of the
 656      vtable entry is treated as a function pointer.  */
 657   if (TARGET_VTABLE_USES_DESCRIPTORS)
 658     aref = build1 (NOP_EXPR, TREE_TYPE (aref),
 659                    cp_build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1,
 660                                    tf_warning_or_error));
 661
 662   /* Remember this as a method reference, for later devirtualization.  */
 663   aref = build3 (OBJ_TYPE_REF, TREE_TYPE (aref), aref, instance_ptr, idx);
 664
 665   return aref;
 666 }
 667
 668 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
 669    for the given TYPE.  */
 670
 671 static tree
 672 get_vtable_name (tree type)
 673 {
 674   return mangle_vtbl_for_type (type);
 675 }
 676
 677 /* DECL is an entity associated with TYPE, like a virtual table or an
 678    implicitly generated constructor.  Determine whether or not DECL
 679    should have external or internal linkage at the object file
 680    level.  This routine does not deal with COMDAT linkage and other
 681    similar complexities; it simply sets TREE_PUBLIC if it possible for
 682    entities in other translation units to contain copies of DECL, in
 683    the abstract.  */
 684
 685 void
 686 set_linkage_according_to_type (tree type, tree decl)
 687 {
 688   /* If TYPE involves a local class in a function with internal
 689      linkage, then DECL should have internal linkage too.  Other local
 690      classes have no linkage -- but if their containing functions
 691      have external linkage, it makes sense for DECL to have external
 692      linkage too.  That will allow template definitions to be merged,
 693      for example.  */
 694   if (no_linkage_check (type, /*relaxed_p=*/true))
 695     {
 696       TREE_PUBLIC (decl) = 0;
 697       DECL_INTERFACE_KNOWN (decl) = 1;
 698     }
 699   else
 700     TREE_PUBLIC (decl) = 1;
 701 }
 702
 703 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
 704    (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
 705    Use NAME for the name of the vtable, and VTABLE_TYPE for its type.  */
 706
 707 static tree
 708 build_vtable (tree class_type, tree name, tree vtable_type)
 709 {
 710   tree decl;
 711
 712   decl = build_lang_decl (VAR_DECL, name, vtable_type);
 713   /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
 714      now to avoid confusion in mangle_decl.  */
 715   SET_DECL_ASSEMBLER_NAME (decl, name);
 716   DECL_CONTEXT (decl) = class_type;
 717   DECL_ARTIFICIAL (decl) = 1;
 718   TREE_STATIC (decl) = 1;
 719   TREE_READONLY (decl) = 1;
 720   DECL_VIRTUAL_P (decl) = 1;
 721   DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN;
 722   DECL_VTABLE_OR_VTT_P (decl) = 1;
 723   /* At one time the vtable info was grabbed 2 words at a time.  This
 724      fails on sparc unless you have 8-byte alignment.  (tiemann) */
 725   DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
 726                            DECL_ALIGN (decl));
 727   set_linkage_according_to_type (class_type, decl);
 728   /* The vtable has not been defined -- yet.  */
 729   DECL_EXTERNAL (decl) = 1;
 730   DECL_NOT_REALLY_EXTERN (decl) = 1;
 731
 732   /* Mark the VAR_DECL node representing the vtable itself as a
 733      "gratuitous" one, thereby forcing dwarfout.c to ignore it.  It
 734      is rather important that such things be ignored because any
 735      effort to actually generate DWARF for them will run into
 736      trouble when/if we encounter code like:
 737
 738      #pragma interface
 739      struct S { virtual void member (); };
 740
 741      because the artificial declaration of the vtable itself (as
 742      manufactured by the g++ front end) will say that the vtable is
 743      a static member of `S' but only *after* the debug output for
 744      the definition of `S' has already been output.  This causes
 745      grief because the DWARF entry for the definition of the vtable
 746      will try to refer back to an earlier *declaration* of the
 747      vtable as a static member of `S' and there won't be one.  We
 748      might be able to arrange to have the "vtable static member"
 749      attached to the member list for `S' before the debug info for
 750      `S' get written (which would solve the problem) but that would
 751      require more intrusive changes to the g++ front end.  */
 752   DECL_IGNORED_P (decl) = 1;
 753
 754   return decl;
 755 }
 756
 757 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
 758    or even complete.  If this does not exist, create it.  If COMPLETE is
 759    nonzero, then complete the definition of it -- that will render it
 760    impossible to actually build the vtable, but is useful to get at those
 761    which are known to exist in the runtime.  */
 762
 763 tree
 764 get_vtable_decl (tree type, int complete)
 765 {
 766   tree decl;
 767
 768   if (CLASSTYPE_VTABLES (type))
 769     return CLASSTYPE_VTABLES (type);
 770
 771   decl = build_vtable (type, get_vtable_name (type), vtbl_type_node);
 772   CLASSTYPE_VTABLES (type) = decl;
 773
 774   if (complete)
 775     {
 776       DECL_EXTERNAL (decl) = 1;
 777       finish_decl (decl, NULL_TREE, NULL_TREE, NULL_TREE);
 778     }
 779
 780   return decl;
 781 }
 782
 783 /* Build the primary virtual function table for TYPE.  If BINFO is
 784    non-NULL, build the vtable starting with the initial approximation
 785    that it is the same as the one which is the head of the association
 786    list.  Returns a nonzero value if a new vtable is actually
 787    created.  */
 788
 789 static int
 790 build_primary_vtable (tree binfo, tree type)
 791 {
 792   tree decl;
 793   tree virtuals;
 794
 795   decl = get_vtable_decl (type, /*complete=*/0);
 796
 797   if (binfo)
 798     {
 799       if (BINFO_NEW_VTABLE_MARKED (binfo))
 800         /* We have already created a vtable for this base, so there's
 801            no need to do it again.  */
 802         return 0;
 803
 804       virtuals = copy_list (BINFO_VIRTUALS (binfo));
 805       TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo));
 806       DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl));
 807       DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
 808     }
 809   else
 810     {
 811       gcc_assert (TREE_TYPE (decl) == vtbl_type_node);
 812       virtuals = NULL_TREE;
 813     }
 814
 815 #ifdef GATHER_STATISTICS
 816   n_vtables += 1;
 817   n_vtable_elems += list_length (virtuals);
 818 #endif
 819
 820   /* Initialize the association list for this type, based
 821      on our first approximation.  */
 822   BINFO_VTABLE (TYPE_BINFO (type)) = decl;
 823   BINFO_VIRTUALS (TYPE_BINFO (type)) = virtuals;
 824   SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type));
 825   return 1;
 826 }
 827
 828 /* Give BINFO a new virtual function table which is initialized
 829    with a skeleton-copy of its original initialization.  The only
 830    entry that changes is the `delta' entry, so we can really
 831    share a lot of structure.
 832
 833    FOR_TYPE is the most derived type which caused this table to
 834    be needed.
 835
 836    Returns nonzero if we haven't met BINFO before.
 837
 838    The order in which vtables are built (by calling this function) for
 839    an object must remain the same, otherwise a binary incompatibility
 840    can result.  */
 841
 842 static int
 843 build_secondary_vtable (tree binfo)
 844 {
 845   if (BINFO_NEW_VTABLE_MARKED (binfo))
 846     /* We already created a vtable for this base.  There's no need to
 847        do it again.  */
 848     return 0;
 849
 850   /* Remember that we've created a vtable for this BINFO, so that we
 851      don't try to do so again.  */
 852   SET_BINFO_NEW_VTABLE_MARKED (binfo);
 853
 854   /* Make fresh virtual list, so we can smash it later.  */
 855   BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
 856
 857   /* Secondary vtables are laid out as part of the same structure as
 858      the primary vtable.  */
 859   BINFO_VTABLE (binfo) = NULL_TREE;
 860   return 1;
 861 }
 862
 863 /* Create a new vtable for BINFO which is the hierarchy dominated by
 864    T. Return nonzero if we actually created a new vtable.  */
 865
 866 static int
 867 make_new_vtable (tree t, tree binfo)
 868 {
 869   if (binfo == TYPE_BINFO (t))
 870     /* In this case, it is *type*'s vtable we are modifying.  We start
 871        with the approximation that its vtable is that of the
 872        immediate base class.  */
 873     return build_primary_vtable (binfo, t);
 874   else
 875     /* This is our very own copy of `basetype' to play with.  Later,
 876        we will fill in all the virtual functions that override the
 877        virtual functions in these base classes which are not defined
 878        by the current type.  */
 879     return build_secondary_vtable (binfo);
 880 }
 881
 882 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
 883    (which is in the hierarchy dominated by T) list FNDECL as its
 884    BV_FN.  DELTA is the required constant adjustment from the `this'
 885    pointer where the vtable entry appears to the `this' required when
 886    the function is actually called.  */
 887
 888 static void
 889 modify_vtable_entry (tree t,
 890                      tree binfo,
 891                      tree fndecl,
 892                      tree delta,
 893                      tree *virtuals)
 894 {
 895   tree v;
 896
 897   v = *virtuals;
 898
 899   if (fndecl != BV_FN (v)
 900       || !tree_int_cst_equal (delta, BV_DELTA (v)))
 901     {
 902       /* We need a new vtable for BINFO.  */
 903       if (make_new_vtable (t, binfo))
 904         {
 905           /* If we really did make a new vtable, we also made a copy
 906              of the BINFO_VIRTUALS list.  Now, we have to find the
 907              corresponding entry in that list.  */
 908           *virtuals = BINFO_VIRTUALS (binfo);
 909           while (BV_FN (*virtuals) != BV_FN (v))
 910             *virtuals = TREE_CHAIN (*virtuals);
 911           v = *virtuals;
 912         }
 913
 914       BV_DELTA (v) = delta;
 915       BV_VCALL_INDEX (v) = NULL_TREE;
 916       BV_FN (v) = fndecl;
 917     }
 918 }
 919
 920 \f
 921 /* Add method METHOD to class TYPE.  If USING_DECL is non-null, it is
 922    the USING_DECL naming METHOD.  Returns true if the method could be
 923    added to the method vec.  */
 924
 925 bool
 926 add_method (tree type, tree method, tree using_decl)
 927 {
 928   unsigned slot;
 929   tree overload;
 930   bool template_conv_p = false;
 931   bool conv_p;
 932   VEC(tree,gc) *method_vec;
 933   bool complete_p;
 934   bool insert_p = false;
 935   tree current_fns;
 936   tree fns;
 937
 938   if (method == error_mark_node)
 939     return false;
 940
 941   complete_p = COMPLETE_TYPE_P (type);
 942   conv_p = DECL_CONV_FN_P (method);
 943   if (conv_p)
 944     template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL
 945                        && DECL_TEMPLATE_CONV_FN_P (method));
 946
 947   method_vec = CLASSTYPE_METHOD_VEC (type);
 948   if (!method_vec)
 949     {
 950       /* Make a new method vector.  We start with 8 entries.  We must
 951          allocate at least two (for constructors and destructors), and
 952          we're going to end up with an assignment operator at some
 953          point as well.  */
 954       method_vec = VEC_alloc (tree, gc, 8);
 955       /* Create slots for constructors and destructors.  */
 956       VEC_quick_push (tree, method_vec, NULL_TREE);
 957       VEC_quick_push (tree, method_vec, NULL_TREE);
 958       CLASSTYPE_METHOD_VEC (type) = method_vec;
 959     }
 960
 961   /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc.  */
 962   grok_special_member_properties (method);
 963
 964   /* Constructors and destructors go in special slots.  */
 965   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method))
 966     slot = CLASSTYPE_CONSTRUCTOR_SLOT;
 967   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
 968     {
 969       slot = CLASSTYPE_DESTRUCTOR_SLOT;
 970
 971       if (TYPE_FOR_JAVA (type))
 972         {
 973           if (!DECL_ARTIFICIAL (method))
 974             error ("Java class %qT cannot have a destructor", type);
 975           else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
 976             error ("Java class %qT cannot have an implicit non-trivial "
 977                    "destructor",
 978                    type);
 979         }
 980     }
 981   else
 982     {
 983       tree m;
 984
 985       insert_p = true;
 986       /* See if we already have an entry with this name.  */
 987       for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
 988            VEC_iterate (tree, method_vec, slot, m);
 989            ++slot)
 990         {
 991           m = OVL_CURRENT (m);
 992           if (template_conv_p)
 993             {
 994               if (TREE_CODE (m) == TEMPLATE_DECL
 995                   && DECL_TEMPLATE_CONV_FN_P (m))
 996                 insert_p = false;
 997               break;
 998             }
 999           if (conv_p && !DECL_CONV_FN_P (m))
1000             break;
1001           if (DECL_NAME (m) == DECL_NAME (method))
1002             {
1003               insert_p = false;
1004               break;
1005             }
1006           if (complete_p
1007               && !DECL_CONV_FN_P (m)
1008               && DECL_NAME (m) > DECL_NAME (method))
1009             break;
1010         }
1011     }
1012   current_fns = insert_p ? NULL_TREE : VEC_index (tree, method_vec, slot);
1013
1014   /* Check to see if we've already got this method.  */
1015   for (fns = current_fns; fns; fns = OVL_NEXT (fns))
1016     {
1017       tree fn = OVL_CURRENT (fns);
1018       tree fn_type;
1019       tree method_type;
1020       tree parms1;
1021       tree parms2;
1022
1023       if (TREE_CODE (fn) != TREE_CODE (method))
1024         continue;
1025
1026       /* [over.load] Member function declarations with the
1027          same name and the same parameter types cannot be
1028          overloaded if any of them is a static member
1029          function declaration.
1030
1031          [namespace.udecl] When a using-declaration brings names
1032          from a base class into a derived class scope, member
1033          functions in the derived class override and/or hide member
1034          functions with the same name and parameter types in a base
1035          class (rather than conflicting).  */
1036       fn_type = TREE_TYPE (fn);
1037       method_type = TREE_TYPE (method);
1038       parms1 = TYPE_ARG_TYPES (fn_type);
1039       parms2 = TYPE_ARG_TYPES (method_type);
1040
1041       /* Compare the quals on the 'this' parm.  Don't compare
1042          the whole types, as used functions are treated as
1043          coming from the using class in overload resolution.  */
1044       if (! DECL_STATIC_FUNCTION_P (fn)
1045           && ! DECL_STATIC_FUNCTION_P (method)
1046           && TREE_TYPE (TREE_VALUE (parms1)) != error_mark_node
1047           && TREE_TYPE (TREE_VALUE (parms2)) != error_mark_node
1048           && (TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms1)))
1049               != TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms2)))))
1050         continue;
1051
1052       /* For templates, the return type and template parameters
1053          must be identical.  */
1054       if (TREE_CODE (fn) == TEMPLATE_DECL
1055           && (!same_type_p (TREE_TYPE (fn_type),
1056                             TREE_TYPE (method_type))
1057               || !comp_template_parms (DECL_TEMPLATE_PARMS (fn),
1058                                        DECL_TEMPLATE_PARMS (method))))
1059         continue;
1060
1061       if (! DECL_STATIC_FUNCTION_P (fn))
1062         parms1 = TREE_CHAIN (parms1);
1063       if (! DECL_STATIC_FUNCTION_P (method))
1064         parms2 = TREE_CHAIN (parms2);
1065
1066       if (compparms (parms1, parms2)
1067           && (!DECL_CONV_FN_P (fn)
1068               || same_type_p (TREE_TYPE (fn_type),
1069                               TREE_TYPE (method_type))))
1070         {
1071           if (using_decl)
1072             {
1073               if (DECL_CONTEXT (fn) == type)
1074                 /* Defer to the local function.  */
1075                 return false;
1076               if (DECL_CONTEXT (fn) == DECL_CONTEXT (method))
1077                 error ("repeated using declaration %q+D", using_decl);
1078               else
1079                 error ("using declaration %q+D conflicts with a previous using declaration",
1080                        using_decl);
1081             }
1082           else
1083             {
1084               error ("%q+#D cannot be overloaded", method);
1085               error ("with %q+#D", fn);
1086             }
1087
1088           /* We don't call duplicate_decls here to merge the
1089              declarations because that will confuse things if the
1090              methods have inline definitions.  In particular, we
1091              will crash while processing the definitions.  */
1092           return false;
1093         }
1094     }
1095
1096   /* A class should never have more than one destructor.  */
1097   if (current_fns && DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
1098     return false;
1099
1100   /* Add the new binding.  */
1101   overload = build_overload (method, current_fns);
1102
1103   if (conv_p)
1104     TYPE_HAS_CONVERSION (type) = 1;
1105   else if (slot >= CLASSTYPE_FIRST_CONVERSION_SLOT && !complete_p)
1106     push_class_level_binding (DECL_NAME (method), overload);
1107
1108   if (insert_p)
1109     {
1110       bool reallocated;
1111
1112       /* We only expect to add few methods in the COMPLETE_P case, so
1113          just make room for one more method in that case.  */
1114       if (complete_p)
1115         reallocated = VEC_reserve_exact (tree, gc, method_vec, 1);
1116       else
1117         reallocated = VEC_reserve (tree, gc, method_vec, 1);
1118       if (reallocated)
1119         CLASSTYPE_METHOD_VEC (type) = method_vec;
1120       if (slot == VEC_length (tree, method_vec))
1121         VEC_quick_push (tree, method_vec, overload);
1122       else
1123         VEC_quick_insert (tree, method_vec, slot, overload);
1124     }
1125   else
1126     /* Replace the current slot.  */
1127     VEC_replace (tree, method_vec, slot, overload);
1128   return true;
1129 }
1130
1131 /* Subroutines of finish_struct.  */
1132
1133 /* Change the access of FDECL to ACCESS in T.  Return 1 if change was
1134    legit, otherwise return 0.  */
1135
1136 static int
1137 alter_access (tree t, tree fdecl, tree access)
1138 {
1139   tree elem;
1140
1141   if (!DECL_LANG_SPECIFIC (fdecl))
1142     retrofit_lang_decl (fdecl);
1143
1144   gcc_assert (!DECL_DISCRIMINATOR_P (fdecl));
1145
1146   elem = purpose_member (t, DECL_ACCESS (fdecl));
1147   if (elem)
1148     {
1149       if (TREE_VALUE (elem) != access)
1150         {
1151           if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1152             error ("conflicting access specifications for method"
1153                    " %q+D, ignored", TREE_TYPE (fdecl));
1154           else
1155             error ("conflicting access specifications for field %qE, ignored",
1156                    DECL_NAME (fdecl));
1157         }
1158       else
1159         {
1160           /* They're changing the access to the same thing they changed
1161              it to before.  That's OK.  */
1162           ;
1163         }
1164     }
1165   else
1166     {
1167       perform_or_defer_access_check (TYPE_BINFO (t), fdecl, fdecl);
1168       DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
1169       return 1;
1170     }
1171   return 0;
1172 }
1173
1174 /* Process the USING_DECL, which is a member of T.  */
1175
1176 static void
1177 handle_using_decl (tree using_decl, tree t)
1178 {
1179   tree decl = USING_DECL_DECLS (using_decl);
1180   tree name = DECL_NAME (using_decl);
1181   tree access
1182     = TREE_PRIVATE (using_decl) ? access_private_node
1183     : TREE_PROTECTED (using_decl) ? access_protected_node
1184     : access_public_node;
1185   tree flist = NULL_TREE;
1186   tree old_value;
1187
1188   gcc_assert (!processing_template_decl && decl);
1189
1190   old_value = lookup_member (t, name, /*protect=*/0, /*want_type=*/false);
1191   if (old_value)
1192     {
1193       if (is_overloaded_fn (old_value))
1194         old_value = OVL_CURRENT (old_value);
1195
1196       if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t)
1197         /* OK */;
1198       else
1199         old_value = NULL_TREE;
1200     }
1201
1202   cp_emit_debug_info_for_using (decl, USING_DECL_SCOPE (using_decl));
1203
1204   if (is_overloaded_fn (decl))
1205     flist = decl;
1206
1207   if (! old_value)
1208     ;
1209   else if (is_overloaded_fn (old_value))
1210     {
1211       if (flist)
1212         /* It's OK to use functions from a base when there are functions with
1213            the same name already present in the current class.  */;
1214       else
1215         {
1216           error ("%q+D invalid in %q#T", using_decl, t);
1217           error ("  because of local method %q+#D with same name",
1218                  OVL_CURRENT (old_value));
1219           return;
1220         }
1221     }
1222   else if (!DECL_ARTIFICIAL (old_value))
1223     {
1224       error ("%q+D invalid in %q#T", using_decl, t);
1225       error ("  because of local member %q+#D with same name", old_value);
1226       return;
1227     }
1228
1229   /* Make type T see field decl FDECL with access ACCESS.  */
1230   if (flist)
1231     for (; flist; flist = OVL_NEXT (flist))
1232       {
1233         add_method (t, OVL_CURRENT (flist), using_decl);
1234         alter_access (t, OVL_CURRENT (flist), access);
1235       }
1236   else
1237     alter_access (t, decl, access);
1238 }
1239 \f
1240 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1241    and NO_CONST_ASN_REF_P.  Also set flag bits in T based on
1242    properties of the bases.  */
1243
1244 static void
1245 check_bases (tree t,
1246              int* cant_have_const_ctor_p,
1247              int* no_const_asn_ref_p)
1248 {
1249   int i;
1250   int seen_non_virtual_nearly_empty_base_p;
1251   tree base_binfo;
1252   tree binfo;
1253
1254   seen_non_virtual_nearly_empty_base_p = 0;
1255
1256   for (binfo = TYPE_BINFO (t), i = 0;
1257        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
1258     {
1259       tree basetype = TREE_TYPE (base_binfo);
1260
1261       gcc_assert (COMPLETE_TYPE_P (basetype));
1262
1263       /* Effective C++ rule 14.  We only need to check TYPE_POLYMORPHIC_P
1264          here because the case of virtual functions but non-virtual
1265          dtor is handled in finish_struct_1.  */
1266       if (!TYPE_POLYMORPHIC_P (basetype))
1267         warning (OPT_Weffc__,
1268                  "base class %q#T has a non-virtual destructor", basetype);
1269
1270       /* If the base class doesn't have copy constructors or
1271          assignment operators that take const references, then the
1272          derived class cannot have such a member automatically
1273          generated.  */
1274       if (! TYPE_HAS_CONST_INIT_REF (basetype))
1275         *cant_have_const_ctor_p = 1;
1276       if (TYPE_HAS_ASSIGN_REF (basetype)
1277           && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1278         *no_const_asn_ref_p = 1;
1279
1280       if (BINFO_VIRTUAL_P (base_binfo))
1281         /* A virtual base does not effect nearly emptiness.  */
1282         ;
1283       else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
1284         {
1285           if (seen_non_virtual_nearly_empty_base_p)
1286             /* And if there is more than one nearly empty base, then the
1287                derived class is not nearly empty either.  */
1288             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1289           else
1290             /* Remember we've seen one.  */
1291             seen_non_virtual_nearly_empty_base_p = 1;
1292         }
1293       else if (!is_empty_class (basetype))
1294         /* If the base class is not empty or nearly empty, then this
1295            class cannot be nearly empty.  */
1296         CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1297
1298       /* A lot of properties from the bases also apply to the derived
1299          class.  */
1300       TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1301       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1302         |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype);
1303       TYPE_HAS_COMPLEX_ASSIGN_REF (t)
1304         |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1305       TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1306       TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype);
1307       CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t)
1308         |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype);
1309       TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_HAS_COMPLEX_DFLT (basetype);
1310     }
1311 }
1312
1313 /* Determine all the primary bases within T.  Sets BINFO_PRIMARY_BASE_P for
1314    those that are primaries.  Sets BINFO_LOST_PRIMARY_P for those
1315    that have had a nearly-empty virtual primary base stolen by some
1316    other base in the hierarchy.  Determines CLASSTYPE_PRIMARY_BASE for
1317    T.  */
1318
1319 static void
1320 determine_primary_bases (tree t)
1321 {
1322   unsigned i;
1323   tree primary = NULL_TREE;
1324   tree type_binfo = TYPE_BINFO (t);
1325   tree base_binfo;
1326
1327   /* Determine the primary bases of our bases.  */
1328   for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1329        base_binfo = TREE_CHAIN (base_binfo))
1330     {
1331       tree primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo));
1332
1333       /* See if we're the non-virtual primary of our inheritance
1334          chain.  */
1335       if (!BINFO_VIRTUAL_P (base_binfo))
1336         {
1337           tree parent = BINFO_INHERITANCE_CHAIN (base_binfo);
1338           tree parent_primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent));
1339
1340           if (parent_primary
1341               && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
1342                                     BINFO_TYPE (parent_primary)))
1343             /* We are the primary binfo.  */
1344             BINFO_PRIMARY_P (base_binfo) = 1;
1345         }
1346       /* Determine if we have a virtual primary base, and mark it so.
1347        */
1348       if (primary && BINFO_VIRTUAL_P (primary))
1349         {
1350           tree this_primary = copied_binfo (primary, base_binfo);
1351
1352           if (BINFO_PRIMARY_P (this_primary))
1353             /* Someone already claimed this base.  */
1354             BINFO_LOST_PRIMARY_P (base_binfo) = 1;
1355           else
1356             {
1357               tree delta;
1358
1359               BINFO_PRIMARY_P (this_primary) = 1;
1360               BINFO_INHERITANCE_CHAIN (this_primary) = base_binfo;
1361
1362               /* A virtual binfo might have been copied from within
1363                  another hierarchy. As we're about to use it as a
1364                  primary base, make sure the offsets match.  */
1365               delta = size_diffop (convert (ssizetype,
1366                                             BINFO_OFFSET (base_binfo)),
1367                                    convert (ssizetype,
1368                                             BINFO_OFFSET (this_primary)));
1369
1370               propagate_binfo_offsets (this_primary, delta);
1371             }
1372         }
1373     }
1374
1375   /* First look for a dynamic direct non-virtual base.  */
1376   for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, base_binfo); i++)
1377     {
1378       tree basetype = BINFO_TYPE (base_binfo);
1379
1380       if (TYPE_CONTAINS_VPTR_P (basetype) && !BINFO_VIRTUAL_P (base_binfo))
1381         {
1382           primary = base_binfo;
1383           goto found;
1384         }
1385     }
1386
1387   /* A "nearly-empty" virtual base class can be the primary base
1388      class, if no non-virtual polymorphic base can be found.  Look for
1389      a nearly-empty virtual dynamic base that is not already a primary
1390      base of something in the hierarchy.  If there is no such base,
1391      just pick the first nearly-empty virtual base.  */
1392
1393   for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1394        base_binfo = TREE_CHAIN (base_binfo))
1395     if (BINFO_VIRTUAL_P (base_binfo)
1396         && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo)))
1397       {
1398         if (!BINFO_PRIMARY_P (base_binfo))
1399           {
1400             /* Found one that is not primary.  */
1401             primary = base_binfo;
1402             goto found;
1403           }
1404         else if (!primary)
1405           /* Remember the first candidate.  */
1406           primary = base_binfo;
1407       }
1408
1409  found:
1410   /* If we've got a primary base, use it.  */
1411   if (primary)
1412     {
1413       tree basetype = BINFO_TYPE (primary);
1414
1415       CLASSTYPE_PRIMARY_BINFO (t) = primary;
1416       if (BINFO_PRIMARY_P (primary))
1417         /* We are stealing a primary base.  */
1418         BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary)) = 1;
1419       BINFO_PRIMARY_P (primary) = 1;
1420       if (BINFO_VIRTUAL_P (primary))
1421         {
1422           tree delta;
1423
1424           BINFO_INHERITANCE_CHAIN (primary) = type_binfo;
1425           /* A virtual binfo might have been copied from within
1426              another hierarchy. As we're about to use it as a primary
1427              base, make sure the offsets match.  */
1428           delta = size_diffop (ssize_int (0),
1429                                convert (ssizetype, BINFO_OFFSET (primary)));
1430
1431           propagate_binfo_offsets (primary, delta);
1432         }
1433
1434       primary = TYPE_BINFO (basetype);
1435
1436       TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1437       BINFO_VTABLE (type_binfo) = BINFO_VTABLE (primary);
1438       BINFO_VIRTUALS (type_binfo) = BINFO_VIRTUALS (primary);
1439     }
1440 }
1441
1442 /* Update the variant types of T.  */
1443
1444 void
1445 fixup_type_variants (tree t)
1446 {
1447   tree variants;
1448
1449   if (!t)
1450     return;
1451
1452   for (variants = TYPE_NEXT_VARIANT (t);
1453        variants;
1454        variants = TYPE_NEXT_VARIANT (variants))
1455     {
1456       /* These fields are in the _TYPE part of the node, not in
1457          the TYPE_LANG_SPECIFIC component, so they are not shared.  */
1458       TYPE_HAS_USER_CONSTRUCTOR (variants) = TYPE_HAS_USER_CONSTRUCTOR (t);
1459       TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1460       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants)
1461         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
1462
1463       TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t);
1464
1465       TYPE_BINFO (variants) = TYPE_BINFO (t);
1466
1467       /* Copy whatever these are holding today.  */
1468       TYPE_VFIELD (variants) = TYPE_VFIELD (t);
1469       TYPE_METHODS (variants) = TYPE_METHODS (t);
1470       TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1471
1472       /* All variants of a class have the same attributes.  */
1473       TYPE_ATTRIBUTES (variants) = TYPE_ATTRIBUTES (t);
1474     }
1475 }
1476
1477 \f
1478 /* Set memoizing fields and bits of T (and its variants) for later
1479    use.  */
1480
1481 static void
1482 finish_struct_bits (tree t)
1483 {
1484   /* Fix up variants (if any).  */
1485   fixup_type_variants (t);
1486
1487   if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) && TYPE_POLYMORPHIC_P (t))
1488     /* For a class w/o baseclasses, 'finish_struct' has set
1489        CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1490        Similarly for a class whose base classes do not have vtables.
1491        When neither of these is true, we might have removed abstract
1492        virtuals (by providing a definition), added some (by declaring
1493        new ones), or redeclared ones from a base class.  We need to
1494        recalculate what's really an abstract virtual at this point (by
1495        looking in the vtables).  */
1496     get_pure_virtuals (t);
1497
1498   /* If this type has a copy constructor or a destructor, force its
1499      mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1500      nonzero.  This will cause it to be passed by invisible reference
1501      and prevent it from being returned in a register.  */
1502   if (! TYPE_HAS_TRIVIAL_INIT_REF (t) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
1503     {
1504       tree variants;
1505       DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1506       for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1507         {
1508           SET_TYPE_MODE (variants, BLKmode);
1509           TREE_ADDRESSABLE (variants) = 1;
1510         }
1511     }
1512 }
1513
1514 /* Issue warnings about T having private constructors, but no friends,
1515    and so forth.
1516
1517    HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1518    static members.  HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1519    non-private static member functions.  */
1520
1521 static void
1522 maybe_warn_about_overly_private_class (tree t)
1523 {
1524   int has_member_fn = 0;
1525   int has_nonprivate_method = 0;
1526   tree fn;
1527
1528   if (!warn_ctor_dtor_privacy
1529       /* If the class has friends, those entities might create and
1530          access instances, so we should not warn.  */
1531       || (CLASSTYPE_FRIEND_CLASSES (t)
1532           || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))
1533       /* We will have warned when the template was declared; there's
1534          no need to warn on every instantiation.  */
1535       || CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1536     /* There's no reason to even consider warning about this
1537        class.  */
1538     return;
1539
1540   /* We only issue one warning, if more than one applies, because
1541      otherwise, on code like:
1542
1543      class A {
1544        // Oops - forgot `public:'
1545        A();
1546        A(const A&);
1547        ~A();
1548      };
1549
1550      we warn several times about essentially the same problem.  */
1551
1552   /* Check to see if all (non-constructor, non-destructor) member
1553      functions are private.  (Since there are no friends or
1554      non-private statics, we can't ever call any of the private member
1555      functions.)  */
1556   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
1557     /* We're not interested in compiler-generated methods; they don't
1558        provide any way to call private members.  */
1559     if (!DECL_ARTIFICIAL (fn))
1560       {
1561         if (!TREE_PRIVATE (fn))
1562           {
1563             if (DECL_STATIC_FUNCTION_P (fn))
1564               /* A non-private static member function is just like a
1565                  friend; it can create and invoke private member
1566                  functions, and be accessed without a class
1567                  instance.  */
1568               return;
1569
1570             has_nonprivate_method = 1;
1571             /* Keep searching for a static member function.  */
1572           }
1573         else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn))
1574           has_member_fn = 1;
1575       }
1576
1577   if (!has_nonprivate_method && has_member_fn)
1578     {
1579       /* There are no non-private methods, and there's at least one
1580          private member function that isn't a constructor or
1581          destructor.  (If all the private members are
1582          constructors/destructors we want to use the code below that
1583          issues error messages specifically referring to
1584          constructors/destructors.)  */
1585       unsigned i;
1586       tree binfo = TYPE_BINFO (t);
1587
1588       for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++)
1589         if (BINFO_BASE_ACCESS (binfo, i) != access_private_node)
1590           {
1591             has_nonprivate_method = 1;
1592             break;
1593           }
1594       if (!has_nonprivate_method)
1595         {
1596           warning (OPT_Wctor_dtor_privacy,
1597                    "all member functions in class %qT are private", t);
1598           return;
1599         }
1600     }
1601
1602   /* Even if some of the member functions are non-private, the class
1603      won't be useful for much if all the constructors or destructors
1604      are private: such an object can never be created or destroyed.  */
1605   fn = CLASSTYPE_DESTRUCTORS (t);
1606   if (fn && TREE_PRIVATE (fn))
1607     {
1608       warning (OPT_Wctor_dtor_privacy,
1609                "%q#T only defines a private destructor and has no friends",
1610                t);
1611       return;
1612     }
1613
1614   /* Warn about classes that have private constructors and no friends.  */
1615   if (TYPE_HAS_USER_CONSTRUCTOR (t)
1616       /* Implicitly generated constructors are always public.  */
1617       && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t)
1618           || !CLASSTYPE_LAZY_COPY_CTOR (t)))
1619     {
1620       int nonprivate_ctor = 0;
1621
1622       /* If a non-template class does not define a copy
1623          constructor, one is defined for it, enabling it to avoid
1624          this warning.  For a template class, this does not
1625          happen, and so we would normally get a warning on:
1626
1627            template <class T> class C { private: C(); };
1628
1629          To avoid this asymmetry, we check TYPE_HAS_INIT_REF.  All
1630          complete non-template or fully instantiated classes have this
1631          flag set.  */
1632       if (!TYPE_HAS_INIT_REF (t))
1633         nonprivate_ctor = 1;
1634       else
1635         for (fn = CLASSTYPE_CONSTRUCTORS (t); fn; fn = OVL_NEXT (fn))
1636           {
1637             tree ctor = OVL_CURRENT (fn);
1638             /* Ideally, we wouldn't count copy constructors (or, in
1639                fact, any constructor that takes an argument of the
1640                class type as a parameter) because such things cannot
1641                be used to construct an instance of the class unless
1642                you already have one.  But, for now at least, we're
1643                more generous.  */
1644             if (! TREE_PRIVATE (ctor))
1645               {
1646                 nonprivate_ctor = 1;
1647                 break;
1648               }
1649           }
1650
1651       if (nonprivate_ctor == 0)
1652         {
1653           warning (OPT_Wctor_dtor_privacy,
1654                    "%q#T only defines private constructors and has no friends",
1655                    t);
1656           return;
1657         }
1658     }
1659 }
1660
1661 static struct {
1662   gt_pointer_operator new_value;
1663   void *cookie;
1664 } resort_data;
1665
1666 /* Comparison function to compare two TYPE_METHOD_VEC entries by name.  */
1667
1668 static int
1669 method_name_cmp (const void* m1_p, const void* m2_p)
1670 {
1671   const tree *const m1 = (const tree *) m1_p;
1672   const tree *const m2 = (const tree *) m2_p;
1673
1674   if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1675     return 0;
1676   if (*m1 == NULL_TREE)
1677     return -1;
1678   if (*m2 == NULL_TREE)
1679     return 1;
1680   if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2)))
1681     return -1;
1682   return 1;
1683 }
1684
1685 /* This routine compares two fields like method_name_cmp but using the
1686    pointer operator in resort_field_decl_data.  */
1687
1688 static int
1689 resort_method_name_cmp (const void* m1_p, const void* m2_p)
1690 {
1691   const tree *const m1 = (const tree *) m1_p;
1692   const tree *const m2 = (const tree *) m2_p;
1693   if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1694     return 0;
1695   if (*m1 == NULL_TREE)
1696     return -1;
1697   if (*m2 == NULL_TREE)
1698     return 1;
1699   {
1700     tree d1 = DECL_NAME (OVL_CURRENT (*m1));
1701     tree d2 = DECL_NAME (OVL_CURRENT (*m2));
1702     resort_data.new_value (&d1, resort_data.cookie);
1703     resort_data.new_value (&d2, resort_data.cookie);
1704     if (d1 < d2)
1705       return -1;
1706   }
1707   return 1;
1708 }
1709
1710 /* Resort TYPE_METHOD_VEC because pointers have been reordered.  */
1711
1712 void
1713 resort_type_method_vec (void* obj,
1714                         void* orig_obj ATTRIBUTE_UNUSED ,
1715                         gt_pointer_operator new_value,
1716                         void* cookie)
1717 {
1718   VEC(tree,gc) *method_vec = (VEC(tree,gc) *) obj;
1719   int len = VEC_length (tree, method_vec);
1720   size_t slot;
1721   tree fn;
1722
1723   /* The type conversion ops have to live at the front of the vec, so we
1724      can't sort them.  */
1725   for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1726        VEC_iterate (tree, method_vec, slot, fn);
1727        ++slot)
1728     if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1729       break;
1730
1731   if (len - slot > 1)
1732     {
1733       resort_data.new_value = new_value;
1734       resort_data.cookie = cookie;
1735       qsort (VEC_address (tree, method_vec) + slot, len - slot, sizeof (tree),
1736              resort_method_name_cmp);
1737     }
1738 }
1739
1740 /* Warn about duplicate methods in fn_fields.
1741
1742    Sort methods that are not special (i.e., constructors, destructors,
1743    and type conversion operators) so that we can find them faster in
1744    search.  */
1745
1746 static void
1747 finish_struct_methods (tree t)
1748 {
1749   tree fn_fields;
1750   VEC(tree,gc) *method_vec;
1751   int slot, len;
1752
1753   method_vec = CLASSTYPE_METHOD_VEC (t);
1754   if (!method_vec)
1755     return;
1756
1757   len = VEC_length (tree, method_vec);
1758
1759   /* Clear DECL_IN_AGGR_P for all functions.  */
1760   for (fn_fields = TYPE_METHODS (t); fn_fields;
1761        fn_fields = TREE_CHAIN (fn_fields))
1762     DECL_IN_AGGR_P (fn_fields) = 0;
1763
1764   /* Issue warnings about private constructors and such.  If there are
1765      no methods, then some public defaults are generated.  */
1766   maybe_warn_about_overly_private_class (t);
1767
1768   /* The type conversion ops have to live at the front of the vec, so we
1769      can't sort them.  */
1770   for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1771        VEC_iterate (tree, method_vec, slot, fn_fields);
1772        ++slot)
1773     if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields)))
1774       break;
1775   if (len - slot > 1)
1776     qsort (VEC_address (tree, method_vec) + slot,
1777            len-slot, sizeof (tree), method_name_cmp);
1778 }
1779
1780 /* Make BINFO's vtable have N entries, including RTTI entries,
1781    vbase and vcall offsets, etc.  Set its type and call the back end
1782    to lay it out.  */
1783
1784 static void
1785 layout_vtable_decl (tree binfo, int n)
1786 {
1787   tree atype;
1788   tree vtable;
1789
1790   atype = build_cplus_array_type (vtable_entry_type,
1791                                   build_index_type (size_int (n - 1)));
1792   layout_type (atype);
1793
1794   /* We may have to grow the vtable.  */
1795   vtable = get_vtbl_decl_for_binfo (binfo);
1796   if (!same_type_p (TREE_TYPE (vtable), atype))
1797     {
1798       TREE_TYPE (vtable) = atype;
1799       DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE;
1800       layout_decl (vtable, 0);
1801     }
1802 }
1803
1804 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1805    have the same signature.  */
1806
1807 int
1808 same_signature_p (const_tree fndecl, const_tree base_fndecl)
1809 {
1810   /* One destructor overrides another if they are the same kind of
1811      destructor.  */
1812   if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl)
1813       && special_function_p (base_fndecl) == special_function_p (fndecl))
1814     return 1;
1815   /* But a non-destructor never overrides a destructor, nor vice
1816      versa, nor do different kinds of destructors override
1817      one-another.  For example, a complete object destructor does not
1818      override a deleting destructor.  */
1819   if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl))
1820     return 0;
1821
1822   if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl)
1823       || (DECL_CONV_FN_P (fndecl)
1824           && DECL_CONV_FN_P (base_fndecl)
1825           && same_type_p (DECL_CONV_FN_TYPE (fndecl),
1826                           DECL_CONV_FN_TYPE (base_fndecl))))
1827     {
1828       tree types, base_types;
1829       types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1830       base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
1831       if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types)))
1832            == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types))))
1833           && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types)))
1834         return 1;
1835     }
1836   return 0;
1837 }
1838
1839 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1840    subobject.  */
1841
1842 static bool
1843 base_derived_from (tree derived, tree base)
1844 {
1845   tree probe;
1846
1847   for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1848     {
1849       if (probe == derived)
1850         return true;
1851       else if (BINFO_VIRTUAL_P (probe))
1852         /* If we meet a virtual base, we can't follow the inheritance
1853            any more.  See if the complete type of DERIVED contains
1854            such a virtual base.  */
1855         return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (derived))
1856                 != NULL_TREE);
1857     }
1858   return false;
1859 }
1860
1861 typedef struct find_final_overrider_data_s {
1862   /* The function for which we are trying to find a final overrider.  */
1863   tree fn;
1864   /* The base class in which the function was declared.  */
1865   tree declaring_base;
1866   /* The candidate overriders.  */
1867   tree candidates;
1868   /* Path to most derived.  */
1869   VEC(tree,heap) *path;
1870 } find_final_overrider_data;
1871
1872 /* Add the overrider along the current path to FFOD->CANDIDATES.
1873    Returns true if an overrider was found; false otherwise.  */
1874
1875 static bool
1876 dfs_find_final_overrider_1 (tree binfo,
1877                             find_final_overrider_data *ffod,
1878                             unsigned depth)
1879 {
1880   tree method;
1881
1882   /* If BINFO is not the most derived type, try a more derived class.
1883      A definition there will overrider a definition here.  */
1884   if (depth)
1885     {
1886       depth--;
1887       if (dfs_find_final_overrider_1
1888           (VEC_index (tree, ffod->path, depth), ffod, depth))
1889         return true;
1890     }
1891
1892   method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
1893   if (method)
1894     {
1895       tree *candidate = &ffod->candidates;
1896
1897       /* Remove any candidates overridden by this new function.  */
1898       while (*candidate)
1899         {
1900           /* If *CANDIDATE overrides METHOD, then METHOD
1901              cannot override anything else on the list.  */
1902           if (base_derived_from (TREE_VALUE (*candidate), binfo))
1903             return true;
1904           /* If METHOD overrides *CANDIDATE, remove *CANDIDATE.  */
1905           if (base_derived_from (binfo, TREE_VALUE (*candidate)))
1906             *candidate = TREE_CHAIN (*candidate);
1907           else
1908             candidate = &TREE_CHAIN (*candidate);
1909         }
1910
1911       /* Add the new function.  */
1912       ffod->candidates = tree_cons (method, binfo, ffod->candidates);
1913       return true;
1914     }
1915
1916   return false;
1917 }
1918
1919 /* Called from find_final_overrider via dfs_walk.  */
1920
1921 static tree
1922 dfs_find_final_overrider_pre (tree binfo, void *data)
1923 {
1924   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1925
1926   if (binfo == ffod->declaring_base)
1927     dfs_find_final_overrider_1 (binfo, ffod, VEC_length (tree, ffod->path));
1928   VEC_safe_push (tree, heap, ffod->path, binfo);
1929
1930   return NULL_TREE;
1931 }
1932
1933 static tree
1934 dfs_find_final_overrider_post (tree binfo ATTRIBUTE_UNUSED, void *data)
1935 {
1936   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1937   VEC_pop (tree, ffod->path);
1938
1939   return NULL_TREE;
1940 }
1941
1942 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1943    FN and whose TREE_VALUE is the binfo for the base where the
1944    overriding occurs.  BINFO (in the hierarchy dominated by the binfo
1945    DERIVED) is the base object in which FN is declared.  */
1946
1947 static tree
1948 find_final_overrider (tree derived, tree binfo, tree fn)
1949 {
1950   find_final_overrider_data ffod;
1951
1952   /* Getting this right is a little tricky.  This is valid:
1953
1954        struct S { virtual void f (); };
1955        struct T { virtual void f (); };
1956        struct U : public S, public T { };
1957
1958      even though calling `f' in `U' is ambiguous.  But,
1959
1960        struct R { virtual void f(); };
1961        struct S : virtual public R { virtual void f (); };
1962        struct T : virtual public R { virtual void f (); };
1963        struct U : public S, public T { };
1964
1965      is not -- there's no way to decide whether to put `S::f' or
1966      `T::f' in the vtable for `R'.
1967
1968      The solution is to look at all paths to BINFO.  If we find
1969      different overriders along any two, then there is a problem.  */
1970   if (DECL_THUNK_P (fn))
1971     fn = THUNK_TARGET (fn);
1972
1973   /* Determine the depth of the hierarchy.  */
1974   ffod.fn = fn;
1975   ffod.declaring_base = binfo;
1976   ffod.candidates = NULL_TREE;
1977   ffod.path = VEC_alloc (tree, heap, 30);
1978
1979   dfs_walk_all (derived, dfs_find_final_overrider_pre,
1980                 dfs_find_final_overrider_post, &ffod);
1981
1982   VEC_free (tree, heap, ffod.path);
1983
1984   /* If there was no winner, issue an error message.  */
1985   if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
1986     return error_mark_node;
1987
1988   return ffod.candidates;
1989 }
1990
1991 /* Return the index of the vcall offset for FN when TYPE is used as a
1992    virtual base.  */
1993
1994 static tree
1995 get_vcall_index (tree fn, tree type)
1996 {
1997   VEC(tree_pair_s,gc) *indices = CLASSTYPE_VCALL_INDICES (type);
1998   tree_pair_p p;
1999   unsigned ix;
2000
2001   for (ix = 0; VEC_iterate (tree_pair_s, indices, ix, p); ix++)
2002     if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (p->purpose))
2003         || same_signature_p (fn, p->purpose))
2004       return p->value;
2005
2006   /* There should always be an appropriate index.  */
2007   gcc_unreachable ();
2008 }
2009
2010 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2011    dominated by T.  FN has been overridden in BINFO; VIRTUALS points to the
2012    corresponding position in the BINFO_VIRTUALS list.  */
2013
2014 static void
2015 update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
2016                             unsigned ix)
2017 {
2018   tree b;
2019   tree overrider;
2020   tree delta;
2021   tree virtual_base;
2022   tree first_defn;
2023   tree overrider_fn, overrider_target;
2024   tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn;
2025   tree over_return, base_return;
2026   bool lost = false;
2027
2028   /* Find the nearest primary base (possibly binfo itself) which defines
2029      this function; this is the class the caller will convert to when
2030      calling FN through BINFO.  */
2031   for (b = binfo; ; b = get_primary_binfo (b))
2032     {
2033       gcc_assert (b);
2034       if (look_for_overrides_here (BINFO_TYPE (b), target_fn))
2035         break;
2036
2037       /* The nearest definition is from a lost primary.  */
2038       if (BINFO_LOST_PRIMARY_P (b))
2039         lost = true;
2040     }
2041   first_defn = b;
2042
2043   /* Find the final overrider.  */
2044   overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn);
2045   if (overrider == error_mark_node)
2046     {
2047       error ("no unique final overrider for %qD in %qT", target_fn, t);
2048       return;
2049     }
2050   overrider_target = overrider_fn = TREE_PURPOSE (overrider);
2051
2052   /* Check for adjusting covariant return types.  */
2053   over_return = TREE_TYPE (TREE_TYPE (overrider_target));
2054   base_return = TREE_TYPE (TREE_TYPE (target_fn));
2055
2056   if (POINTER_TYPE_P (over_return)
2057       && TREE_CODE (over_return) == TREE_CODE (base_return)
2058       && CLASS_TYPE_P (TREE_TYPE (over_return))
2059       && CLASS_TYPE_P (TREE_TYPE (base_return))
2060       /* If the overrider is invalid, don't even try.  */
2061       && !DECL_INVALID_OVERRIDER_P (overrider_target))
2062     {
2063       /* If FN is a covariant thunk, we must figure out the adjustment
2064          to the final base FN was converting to. As OVERRIDER_TARGET might
2065          also be converting to the return type of FN, we have to
2066          combine the two conversions here.  */
2067       tree fixed_offset, virtual_offset;
2068
2069       over_return = TREE_TYPE (over_return);
2070       base_return = TREE_TYPE (base_return);
2071
2072       if (DECL_THUNK_P (fn))
2073         {
2074           gcc_assert (DECL_RESULT_THUNK_P (fn));
2075           fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn));
2076           virtual_offset = THUNK_VIRTUAL_OFFSET (fn);
2077         }
2078       else
2079         fixed_offset = virtual_offset = NULL_TREE;
2080
2081       if (virtual_offset)
2082         /* Find the equivalent binfo within the return type of the
2083            overriding function. We will want the vbase offset from
2084            there.  */
2085         virtual_offset = binfo_for_vbase (BINFO_TYPE (virtual_offset),
2086                                           over_return);
2087       else if (!same_type_ignoring_top_level_qualifiers_p
2088                (over_return, base_return))
2089         {
2090           /* There was no existing virtual thunk (which takes
2091              precedence).  So find the binfo of the base function's
2092              return type within the overriding function's return type.
2093              We cannot call lookup base here, because we're inside a
2094              dfs_walk, and will therefore clobber the BINFO_MARKED
2095              flags.  Fortunately we know the covariancy is valid (it
2096              has already been checked), so we can just iterate along
2097              the binfos, which have been chained in inheritance graph
2098              order.  Of course it is lame that we have to repeat the
2099              search here anyway -- we should really be caching pieces
2100              of the vtable and avoiding this repeated work.  */
2101           tree thunk_binfo, base_binfo;
2102
2103           /* Find the base binfo within the overriding function's
2104              return type.  We will always find a thunk_binfo, except
2105              when the covariancy is invalid (which we will have
2106              already diagnosed).  */
2107           for (base_binfo = TYPE_BINFO (base_return),
2108                thunk_binfo = TYPE_BINFO (over_return);
2109                thunk_binfo;
2110                thunk_binfo = TREE_CHAIN (thunk_binfo))
2111             if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo),
2112                                    BINFO_TYPE (base_binfo)))
2113               break;
2114
2115           /* See if virtual inheritance is involved.  */
2116           for (virtual_offset = thunk_binfo;
2117                virtual_offset;
2118                virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset))
2119             if (BINFO_VIRTUAL_P (virtual_offset))
2120               break;
2121
2122           if (virtual_offset
2123               || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo)))
2124             {
2125               tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2126
2127               if (virtual_offset)
2128                 {
2129                   /* We convert via virtual base.  Adjust the fixed
2130                      offset to be from there.  */
2131                   offset = size_diffop
2132                     (offset, convert
2133                      (ssizetype, BINFO_OFFSET (virtual_offset)));
2134                 }
2135               if (fixed_offset)
2136                 /* There was an existing fixed offset, this must be
2137                    from the base just converted to, and the base the
2138                    FN was thunking to.  */
2139                 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2140               else
2141                 fixed_offset = offset;
2142             }
2143         }
2144
2145       if (fixed_offset || virtual_offset)
2146         /* Replace the overriding function with a covariant thunk.  We
2147            will emit the overriding function in its own slot as
2148            well.  */
2149         overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0,
2150                                    fixed_offset, virtual_offset);
2151     }
2152   else
2153     gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target) ||
2154                 !DECL_THUNK_P (fn));
2155
2156   /* Assume that we will produce a thunk that convert all the way to
2157      the final overrider, and not to an intermediate virtual base.  */
2158   virtual_base = NULL_TREE;
2159
2160   /* See if we can convert to an intermediate virtual base first, and then
2161      use the vcall offset located there to finish the conversion.  */
2162   for (; b; b = BINFO_INHERITANCE_CHAIN (b))
2163     {
2164       /* If we find the final overrider, then we can stop
2165          walking.  */
2166       if (SAME_BINFO_TYPE_P (BINFO_TYPE (b),
2167                              BINFO_TYPE (TREE_VALUE (overrider))))
2168         break;
2169
2170       /* If we find a virtual base, and we haven't yet found the
2171          overrider, then there is a virtual base between the
2172          declaring base (first_defn) and the final overrider.  */
2173       if (BINFO_VIRTUAL_P (b))
2174         {
2175           virtual_base = b;
2176           break;
2177         }
2178     }
2179
2180   if (overrider_fn != overrider_target && !virtual_base)
2181     {
2182       /* The ABI specifies that a covariant thunk includes a mangling
2183          for a this pointer adjustment.  This-adjusting thunks that
2184          override a function from a virtual base have a vcall
2185          adjustment.  When the virtual base in question is a primary
2186          virtual base, we know the adjustments are zero, (and in the
2187          non-covariant case, we would not use the thunk).
2188          Unfortunately we didn't notice this could happen, when
2189          designing the ABI and so never mandated that such a covariant
2190          thunk should be emitted.  Because we must use the ABI mandated
2191          name, we must continue searching from the binfo where we
2192          found the most recent definition of the function, towards the
2193          primary binfo which first introduced the function into the
2194          vtable.  If that enters a virtual base, we must use a vcall
2195          this-adjusting thunk.  Bleah! */
2196       tree probe = first_defn;
2197
2198       while ((probe = get_primary_binfo (probe))
2199              && (unsigned) list_length (BINFO_VIRTUALS (probe)) > ix)
2200         if (BINFO_VIRTUAL_P (probe))
2201           virtual_base = probe;
2202
2203       if (virtual_base)
2204         /* Even if we find a virtual base, the correct delta is
2205            between the overrider and the binfo we're building a vtable
2206            for.  */
2207         goto virtual_covariant;
2208     }
2209
2210   /* Compute the constant adjustment to the `this' pointer.  The
2211      `this' pointer, when this function is called, will point at BINFO
2212      (or one of its primary bases, which are at the same offset).  */
2213   if (virtual_base)
2214     /* The `this' pointer needs to be adjusted from the declaration to
2215        the nearest virtual base.  */
2216     delta = size_diffop (convert (ssizetype, BINFO_OFFSET (virtual_base)),
2217                          convert (ssizetype, BINFO_OFFSET (first_defn)));
2218   else if (lost)
2219     /* If the nearest definition is in a lost primary, we don't need an
2220        entry in our vtable.  Except possibly in a constructor vtable,
2221        if we happen to get our primary back.  In that case, the offset
2222        will be zero, as it will be a primary base.  */
2223     delta = size_zero_node;
2224   else
2225     /* The `this' pointer needs to be adjusted from pointing to
2226        BINFO to pointing at the base where the final overrider
2227        appears.  */
2228     virtual_covariant:
2229     delta = size_diffop (convert (ssizetype,
2230                                   BINFO_OFFSET (TREE_VALUE (overrider))),
2231                          convert (ssizetype, BINFO_OFFSET (binfo)));
2232
2233   modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals);
2234
2235   if (virtual_base)
2236     BV_VCALL_INDEX (*virtuals)
2237       = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base));
2238   else
2239     BV_VCALL_INDEX (*virtuals) = NULL_TREE;
2240 }
2241
2242 /* Called from modify_all_vtables via dfs_walk.  */
2243
2244 static tree
2245 dfs_modify_vtables (tree binfo, void* data)
2246 {
2247   tree t = (tree) data;
2248   tree virtuals;
2249   tree old_virtuals;
2250   unsigned ix;
2251
2252   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
2253     /* A base without a vtable needs no modification, and its bases
2254        are uninteresting.  */
2255     return dfs_skip_bases;
2256
2257   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t)
2258       && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
2259     /* Don't do the primary vtable, if it's new.  */
2260     return NULL_TREE;
2261
2262   if (BINFO_PRIMARY_P (binfo) && !BINFO_VIRTUAL_P (binfo))
2263     /* There's no need to modify the vtable for a non-virtual primary
2264        base; we're not going to use that vtable anyhow.  We do still
2265        need to do this for virtual primary bases, as they could become
2266        non-primary in a construction vtable.  */
2267     return NULL_TREE;
2268
2269   make_new_vtable (t, binfo);
2270
2271   /* Now, go through each of the virtual functions in the virtual
2272      function table for BINFO.  Find the final overrider, and update
2273      the BINFO_VIRTUALS list appropriately.  */
2274   for (ix = 0, virtuals = BINFO_VIRTUALS (binfo),
2275          old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
2276        virtuals;
2277        ix++, virtuals = TREE_CHAIN (virtuals),
2278          old_virtuals = TREE_CHAIN (old_virtuals))
2279     update_vtable_entry_for_fn (t,
2280                                 binfo,
2281                                 BV_FN (old_virtuals),
2282                                 &virtuals, ix);
2283
2284   return NULL_TREE;
2285 }
2286
2287 /* Update all of the primary and secondary vtables for T.  Create new
2288    vtables as required, and initialize their RTTI information.  Each
2289    of the functions in VIRTUALS is declared in T and may override a
2290    virtual function from a base class; find and modify the appropriate
2291    entries to point to the overriding functions.  Returns a list, in
2292    declaration order, of the virtual functions that are declared in T,
2293    but do not appear in the primary base class vtable, and which
2294    should therefore be appended to the end of the vtable for T.  */
2295
2296 static tree
2297 modify_all_vtables (tree t, tree virtuals)
2298 {
2299   tree binfo = TYPE_BINFO (t);
2300   tree *fnsp;
2301
2302   /* Update all of the vtables.  */
2303   dfs_walk_once (binfo, dfs_modify_vtables, NULL, t);
2304
2305   /* Add virtual functions not already in our primary vtable. These
2306      will be both those introduced by this class, and those overridden
2307      from secondary bases.  It does not include virtuals merely
2308      inherited from secondary bases.  */
2309   for (fnsp = &virtuals; *fnsp; )
2310     {
2311       tree fn = TREE_VALUE (*fnsp);
2312
2313       if (!value_member (fn, BINFO_VIRTUALS (binfo))
2314           || DECL_VINDEX (fn) == error_mark_node)
2315         {
2316           /* We don't need to adjust the `this' pointer when
2317              calling this function.  */
2318           BV_DELTA (*fnsp) = integer_zero_node;
2319           BV_VCALL_INDEX (*fnsp) = NULL_TREE;
2320
2321           /* This is a function not already in our vtable.  Keep it.  */
2322           fnsp = &TREE_CHAIN (*fnsp);
2323         }
2324       else
2325         /* We've already got an entry for this function.  Skip it.  */
2326         *fnsp = TREE_CHAIN (*fnsp);
2327     }
2328
2329   return virtuals;
2330 }
2331
2332 /* Get the base virtual function declarations in T that have the
2333    indicated NAME.  */
2334
2335 static tree
2336 get_basefndecls (tree name, tree t)
2337 {
2338   tree methods;
2339   tree base_fndecls = NULL_TREE;
2340   int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
2341   int i;
2342
2343   /* Find virtual functions in T with the indicated NAME.  */
2344   i = lookup_fnfields_1 (t, name);
2345   if (i != -1)
2346     for (methods = VEC_index (tree, CLASSTYPE_METHOD_VEC (t), i);
2347          methods;
2348          methods = OVL_NEXT (methods))
2349       {
2350         tree method = OVL_CURRENT (methods);
2351
2352         if (TREE_CODE (method) == FUNCTION_DECL
2353             && DECL_VINDEX (method))
2354           base_fndecls = tree_cons (NULL_TREE, method, base_fndecls);
2355       }
2356
2357   if (base_fndecls)
2358     return base_fndecls;
2359
2360   for (i = 0; i < n_baseclasses; i++)
2361     {
2362       tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t), i));
2363       base_fndecls = chainon (get_basefndecls (name, basetype),
2364                               base_fndecls);
2365     }
2366
2367   return base_fndecls;
2368 }
2369
2370 /* If this declaration supersedes the declaration of
2371    a method declared virtual in the base class, then
2372    mark this field as being virtual as well.  */
2373
2374 void
2375 check_for_override (tree decl, tree ctype)
2376 {
2377   if (TREE_CODE (decl) == TEMPLATE_DECL)
2378     /* In [temp.mem] we have:
2379
2380          A specialization of a member function template does not
2381          override a virtual function from a base class.  */
2382     return;
2383   if ((DECL_DESTRUCTOR_P (decl)
2384        || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl))
2385        || DECL_CONV_FN_P (decl))
2386       && look_for_overrides (ctype, decl)
2387       && !DECL_STATIC_FUNCTION_P (decl))
2388     /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2389        the error_mark_node so that we know it is an overriding
2390        function.  */
2391     DECL_VINDEX (decl) = decl;
2392
2393   if (DECL_VIRTUAL_P (decl))
2394     {
2395       if (!DECL_VINDEX (decl))
2396         DECL_VINDEX (decl) = error_mark_node;
2397       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2398     }
2399 }
2400
2401 /* Warn about hidden virtual functions that are not overridden in t.
2402    We know that constructors and destructors don't apply.  */
2403
2404 static void
2405 warn_hidden (tree t)
2406 {
2407   VEC(tree,gc) *method_vec = CLASSTYPE_METHOD_VEC (t);
2408   tree fns;
2409   size_t i;
2410
2411   /* We go through each separately named virtual function.  */
2412   for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
2413        VEC_iterate (tree, method_vec, i, fns);
2414        ++i)
2415     {
2416       tree fn;
2417       tree name;
2418       tree fndecl;
2419       tree base_fndecls;
2420       tree base_binfo;
2421       tree binfo;
2422       int j;
2423
2424       /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2425          have the same name.  Figure out what name that is.  */
2426       name = DECL_NAME (OVL_CURRENT (fns));
2427       /* There are no possibly hidden functions yet.  */
2428       base_fndecls = NULL_TREE;
2429       /* Iterate through all of the base classes looking for possibly
2430          hidden functions.  */
2431       for (binfo = TYPE_BINFO (t), j = 0;
2432            BINFO_BASE_ITERATE (binfo, j, base_binfo); j++)
2433         {
2434           tree basetype = BINFO_TYPE (base_binfo);
2435           base_fndecls = chainon (get_basefndecls (name, basetype),
2436                                   base_fndecls);
2437         }
2438
2439       /* If there are no functions to hide, continue.  */
2440       if (!base_fndecls)
2441         continue;
2442
2443       /* Remove any overridden functions.  */
2444       for (fn = fns; fn; fn = OVL_NEXT (fn))
2445         {
2446           fndecl = OVL_CURRENT (fn);
2447           if (DECL_VINDEX (fndecl))
2448             {
2449               tree *prev = &base_fndecls;
2450
2451               while (*prev)
2452                 /* If the method from the base class has the same
2453                    signature as the method from the derived class, it
2454                    has been overridden.  */
2455                 if (same_signature_p (fndecl, TREE_VALUE (*prev)))
2456                   *prev = TREE_CHAIN (*prev);
2457                 else
2458                   prev = &TREE_CHAIN (*prev);
2459             }
2460         }
2461
2462       /* Now give a warning for all base functions without overriders,
2463          as they are hidden.  */
2464       while (base_fndecls)
2465         {
2466           /* Here we know it is a hider, and no overrider exists.  */
2467           warning (OPT_Woverloaded_virtual, "%q+D was hidden", TREE_VALUE (base_fndecls));
2468           warning (OPT_Woverloaded_virtual, "  by %q+D", fns);
2469           base_fndecls = TREE_CHAIN (base_fndecls);
2470         }
2471     }
2472 }
2473
2474 /* Check for things that are invalid.  There are probably plenty of other
2475    things we should check for also.  */
2476
2477 static void
2478 finish_struct_anon (tree t)
2479 {
2480   tree field;
2481
2482   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2483     {
2484       if (TREE_STATIC (field))
2485         continue;
2486       if (TREE_CODE (field) != FIELD_DECL)
2487         continue;
2488
2489       if (DECL_NAME (field) == NULL_TREE
2490           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2491         {
2492           bool is_union = TREE_CODE (TREE_TYPE (field)) == UNION_TYPE;
2493           tree elt = TYPE_FIELDS (TREE_TYPE (field));
2494           for (; elt; elt = TREE_CHAIN (elt))
2495             {
2496               /* We're generally only interested in entities the user
2497                  declared, but we also find nested classes by noticing
2498                  the TYPE_DECL that we create implicitly.  You're
2499                  allowed to put one anonymous union inside another,
2500                  though, so we explicitly tolerate that.  We use
2501                  TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2502                  we also allow unnamed types used for defining fields.  */
2503               if (DECL_ARTIFICIAL (elt)
2504                   && (!DECL_IMPLICIT_TYPEDEF_P (elt)
2505                       || TYPE_ANONYMOUS_P (TREE_TYPE (elt))))
2506                 continue;
2507
2508               if (TREE_CODE (elt) != FIELD_DECL)
2509                 {
2510                   if (is_union)
2511                     permerror (input_location, "%q+#D invalid; an anonymous union can "
2512                                "only have non-static data members", elt);
2513                   else
2514                     permerror (input_location, "%q+#D invalid; an anonymous struct can "
2515                                "only have non-static data members", elt);
2516                   continue;
2517                 }
2518
2519               if (TREE_PRIVATE (elt))
2520                 {
2521                   if (is_union)
2522                     permerror (input_location, "private member %q+#D in anonymous union", elt);
2523                   else
2524                     permerror (input_location, "private member %q+#D in anonymous struct", elt);
2525                 }
2526               else if (TREE_PROTECTED (elt))
2527                 {
2528                   if (is_union)
2529                     permerror (input_location, "protected member %q+#D in anonymous union", elt);
2530                   else
2531                     permerror (input_location, "protected member %q+#D in anonymous struct", elt);
2532                 }
2533
2534               TREE_PRIVATE (elt) = TREE_PRIVATE (field);
2535               TREE_PROTECTED (elt) = TREE_PROTECTED (field);
2536             }
2537         }
2538     }
2539 }
2540
2541 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2542    will be used later during class template instantiation.
2543    When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2544    a non-static member data (FIELD_DECL), a member function
2545    (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2546    a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2547    When FRIEND_P is nonzero, T is either a friend class
2548    (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2549    (FUNCTION_DECL, TEMPLATE_DECL).  */
2550
2551 void
2552 maybe_add_class_template_decl_list (tree type, tree t, int friend_p)
2553 {
2554   /* Save some memory by not creating TREE_LIST if TYPE is not template.  */
2555   if (CLASSTYPE_TEMPLATE_INFO (type))
2556     CLASSTYPE_DECL_LIST (type)
2557       = tree_cons (friend_p ? NULL_TREE : type,
2558                    t, CLASSTYPE_DECL_LIST (type));
2559 }
2560
2561 /* Create default constructors, assignment operators, and so forth for
2562    the type indicated by T, if they are needed.  CANT_HAVE_CONST_CTOR,
2563    and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
2564    the class cannot have a default constructor, copy constructor
2565    taking a const reference argument, or an assignment operator taking
2566    a const reference, respectively.  */
2567
2568 static void
2569 add_implicitly_declared_members (tree t,
2570                                  int cant_have_const_cctor,
2571                                  int cant_have_const_assignment)
2572 {
2573   /* Destructor.  */
2574   if (!CLASSTYPE_DESTRUCTORS (t))
2575     {
2576       /* In general, we create destructors lazily.  */
2577       CLASSTYPE_LAZY_DESTRUCTOR (t) = 1;
2578       /* However, if the implicit destructor is non-trivial
2579          destructor, we sometimes have to create it at this point.  */
2580       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
2581         {
2582           bool lazy_p = true;
2583
2584           if (TYPE_FOR_JAVA (t))
2585             /* If this a Java class, any non-trivial destructor is
2586                invalid, even if compiler-generated.  Therefore, if the
2587                destructor is non-trivial we create it now.  */
2588             lazy_p = false;
2589           else
2590             {
2591               tree binfo;
2592               tree base_binfo;
2593               int ix;
2594
2595               /* If the implicit destructor will be virtual, then we must
2596                  generate it now because (unfortunately) we do not
2597                  generate virtual tables lazily.  */
2598               binfo = TYPE_BINFO (t);
2599               for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
2600                 {
2601                   tree base_type;
2602                   tree dtor;
2603
2604                   base_type = BINFO_TYPE (base_binfo);
2605                   dtor = CLASSTYPE_DESTRUCTORS (base_type);
2606                   if (dtor && DECL_VIRTUAL_P (dtor))
2607                     {
2608                       lazy_p = false;
2609                       break;
2610                     }
2611                 }
2612             }
2613
2614           /* If we can't get away with being lazy, generate the destructor
2615              now.  */
2616           if (!lazy_p)
2617             lazily_declare_fn (sfk_destructor, t);
2618         }
2619     }
2620
2621   /* [class.ctor]
2622
2623      If there is no user-declared constructor for a class, a default
2624      constructor is implicitly declared.  */
2625   if (! TYPE_HAS_USER_CONSTRUCTOR (t))
2626     {
2627       TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1;
2628       CLASSTYPE_LAZY_DEFAULT_CTOR (t) = 1;
2629     }
2630
2631   /* [class.ctor]
2632
2633      If a class definition does not explicitly declare a copy
2634      constructor, one is declared implicitly.  */
2635   if (! TYPE_HAS_INIT_REF (t) && ! TYPE_FOR_JAVA (t))
2636     {
2637       TYPE_HAS_INIT_REF (t) = 1;
2638       TYPE_HAS_CONST_INIT_REF (t) = !cant_have_const_cctor;
2639       CLASSTYPE_LAZY_COPY_CTOR (t) = 1;
2640     }
2641
2642   /* If there is no assignment operator, one will be created if and
2643      when it is needed.  For now, just record whether or not the type
2644      of the parameter to the assignment operator will be a const or
2645      non-const reference.  */
2646   if (!TYPE_HAS_ASSIGN_REF (t) && !TYPE_FOR_JAVA (t))
2647     {
2648       TYPE_HAS_ASSIGN_REF (t) = 1;
2649       TYPE_HAS_CONST_ASSIGN_REF (t) = !cant_have_const_assignment;
2650       CLASSTYPE_LAZY_ASSIGNMENT_OP (t) = 1;
2651     }
2652 }
2653
2654 /* Subroutine of finish_struct_1.  Recursively count the number of fields
2655    in TYPE, including anonymous union members.  */
2656
2657 static int
2658 count_fields (tree fields)
2659 {
2660   tree x;
2661   int n_fields = 0;
2662   for (x = fields; x; x = TREE_CHAIN (x))
2663     {
2664       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2665         n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
2666       else
2667         n_fields += 1;
2668     }
2669   return n_fields;
2670 }
2671
2672 /* Subroutine of finish_struct_1.  Recursively add all the fields in the
2673    TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX.  */
2674
2675 static int
2676 add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx)
2677 {
2678   tree x;
2679   for (x = fields; x; x = TREE_CHAIN (x))
2680     {
2681       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2682         idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
2683       else
2684         field_vec->elts[idx++] = x;
2685     }
2686   return idx;
2687 }
2688
2689 /* FIELD is a bit-field.  We are finishing the processing for its
2690    enclosing type.  Issue any appropriate messages and set appropriate
2691    flags.  Returns false if an error has been diagnosed.  */
2692
2693 static bool
2694 check_bitfield_decl (tree field)
2695 {
2696   tree type = TREE_TYPE (field);
2697   tree w;
2698
2699   /* Extract the declared width of the bitfield, which has been
2700      temporarily stashed in DECL_INITIAL.  */
2701   w = DECL_INITIAL (field);
2702   gcc_assert (w != NULL_TREE);
2703   /* Remove the bit-field width indicator so that the rest of the
2704      compiler does not treat that value as an initializer.  */
2705   DECL_INITIAL (field) = NULL_TREE;
2706
2707   /* Detect invalid bit-field type.  */
2708   if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
2709     {
2710       error ("bit-field %q+#D with non-integral type", field);
2711       w = error_mark_node;
2712     }
2713   else
2714     {
2715       /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs.  */
2716       STRIP_NOPS (w);
2717
2718       /* detect invalid field size.  */
2719       w = integral_constant_value (w);
2720
2721       if (TREE_CODE (w) != INTEGER_CST)
2722         {
2723           error ("bit-field %q+D width not an integer constant", field);
2724           w = error_mark_node;
2725         }
2726       else if (tree_int_cst_sgn (w) < 0)
2727         {
2728           error ("negative width in bit-field %q+D", field);
2729           w = error_mark_node;
2730         }
2731       else if (integer_zerop (w) && DECL_NAME (field) != 0)
2732         {
2733           error ("zero width for bit-field %q+D", field);
2734           w = error_mark_node;
2735         }
2736       else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2737                && TREE_CODE (type) != ENUMERAL_TYPE
2738                && TREE_CODE (type) != BOOLEAN_TYPE)
2739         warning (0, "width of %q+D exceeds its type", field);
2740       else if (TREE_CODE (type) == ENUMERAL_TYPE
2741                && (0 > compare_tree_int (w,
2742                                          tree_int_cst_min_precision
2743                                          (TYPE_MIN_VALUE (type),
2744                                           TYPE_UNSIGNED (type)))
2745                    ||  0 > compare_tree_int (w,
2746                                              tree_int_cst_min_precision
2747                                              (TYPE_MAX_VALUE (type),
2748                                               TYPE_UNSIGNED (type)))))
2749         warning (0, "%q+D is too small to hold all values of %q#T", field, type);
2750     }
2751
2752   if (w != error_mark_node)
2753     {
2754       DECL_SIZE (field) = convert (bitsizetype, w);
2755       DECL_BIT_FIELD (field) = 1;
2756       return true;
2757     }
2758   else
2759     {
2760       /* Non-bit-fields are aligned for their type.  */
2761       DECL_BIT_FIELD (field) = 0;
2762       CLEAR_DECL_C_BIT_FIELD (field);
2763       return false;
2764     }
2765 }
2766
2767 /* FIELD is a non bit-field.  We are finishing the processing for its
2768    enclosing type T.  Issue any appropriate messages and set appropriate
2769    flags.  */
2770
2771 static void
2772 check_field_decl (tree field,
2773                   tree t,
2774                   int* cant_have_const_ctor,
2775                   int* no_const_asn_ref,
2776                   int* any_default_members)
2777 {
2778   tree type = strip_array_types (TREE_TYPE (field));
2779
2780   /* An anonymous union cannot contain any fields which would change
2781      the settings of CANT_HAVE_CONST_CTOR and friends.  */
2782   if (ANON_UNION_TYPE_P (type))
2783     ;
2784   /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2785      structs.  So, we recurse through their fields here.  */
2786   else if (ANON_AGGR_TYPE_P (type))
2787     {
2788       tree fields;
2789
2790       for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2791         if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2792           check_field_decl (fields, t, cant_have_const_ctor,
2793                             no_const_asn_ref, any_default_members);
2794     }
2795   /* Check members with class type for constructors, destructors,
2796      etc.  */
2797   else if (CLASS_TYPE_P (type))
2798     {
2799       /* Never let anything with uninheritable virtuals
2800          make it through without complaint.  */
2801       abstract_virtuals_error (field, type);
2802
2803       if (TREE_CODE (t) == UNION_TYPE)
2804         {
2805           if (TYPE_NEEDS_CONSTRUCTING (type))
2806             error ("member %q+#D with constructor not allowed in union",
2807                    field);
2808           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2809             error ("member %q+#D with destructor not allowed in union", field);
2810           if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2811             error ("member %q+#D with copy assignment operator not allowed in union",
2812                    field);
2813         }
2814       else
2815         {
2816           TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2817           TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2818             |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2819           TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
2820           TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
2821           TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_HAS_COMPLEX_DFLT (type);
2822         }
2823
2824       if (!TYPE_HAS_CONST_INIT_REF (type))
2825         *cant_have_const_ctor = 1;
2826
2827       if (!TYPE_HAS_CONST_ASSIGN_REF (type))
2828         *no_const_asn_ref = 1;
2829     }
2830   if (DECL_INITIAL (field) != NULL_TREE)
2831     {
2832       /* `build_class_init_list' does not recognize
2833          non-FIELD_DECLs.  */
2834       if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
2835         error ("multiple fields in union %qT initialized", t);
2836       *any_default_members = 1;
2837     }
2838 }
2839
2840 /* Check the data members (both static and non-static), class-scoped
2841    typedefs, etc., appearing in the declaration of T.  Issue
2842    appropriate diagnostics.  Sets ACCESS_DECLS to a list (in
2843    declaration order) of access declarations; each TREE_VALUE in this
2844    list is a USING_DECL.
2845
2846    In addition, set the following flags:
2847
2848      EMPTY_P
2849        The class is empty, i.e., contains no non-static data members.
2850
2851      CANT_HAVE_CONST_CTOR_P
2852        This class cannot have an implicitly generated copy constructor
2853        taking a const reference.
2854
2855      CANT_HAVE_CONST_ASN_REF
2856        This class cannot have an implicitly generated assignment
2857        operator taking a const reference.
2858
2859    All of these flags should be initialized before calling this
2860    function.
2861
2862    Returns a pointer to the end of the TYPE_FIELDs chain; additional
2863    fields can be added by adding to this chain.  */
2864
2865 static void
2866 check_field_decls (tree t, tree *access_decls,
2867                    int *cant_have_const_ctor_p,
2868                    int *no_const_asn_ref_p)
2869 {
2870   tree *field;
2871   tree *next;
2872   bool has_pointers;
2873   int any_default_members;
2874   int cant_pack = 0;
2875
2876   /* Assume there are no access declarations.  */
2877   *access_decls = NULL_TREE;
2878   /* Assume this class has no pointer members.  */
2879   has_pointers = false;
2880   /* Assume none of the members of this class have default
2881      initializations.  */
2882   any_default_members = 0;
2883
2884   for (field = &TYPE_FIELDS (t); *field; field = next)
2885     {
2886       tree x = *field;
2887       tree type = TREE_TYPE (x);
2888
2889       next = &TREE_CHAIN (x);
2890
2891       if (TREE_CODE (x) == USING_DECL)
2892         {
2893           /* Prune the access declaration from the list of fields.  */
2894           *field = TREE_CHAIN (x);
2895
2896           /* Save the access declarations for our caller.  */
2897           *access_decls = tree_cons (NULL_TREE, x, *access_decls);
2898
2899           /* Since we've reset *FIELD there's no reason to skip to the
2900              next field.  */
2901           next = field;
2902           continue;
2903         }
2904
2905       if (TREE_CODE (x) == TYPE_DECL
2906           || TREE_CODE (x) == TEMPLATE_DECL)
2907         continue;
2908
2909       /* If we've gotten this far, it's a data member, possibly static,
2910          or an enumerator.  */
2911       DECL_CONTEXT (x) = t;
2912
2913       /* When this goes into scope, it will be a non-local reference.  */
2914       DECL_NONLOCAL (x) = 1;
2915
2916       if (TREE_CODE (t) == UNION_TYPE)
2917         {
2918           /* [class.union]
2919
2920              If a union contains a static data member, or a member of
2921              reference type, the program is ill-formed.  */
2922           if (TREE_CODE (x) == VAR_DECL)
2923             {
2924               error ("%q+D may not be static because it is a member of a union", x);
2925               continue;
2926             }
2927           if (TREE_CODE (type) == REFERENCE_TYPE)
2928             {
2929               error ("%q+D may not have reference type %qT because"
2930                      " it is a member of a union",
2931                      x, type);
2932               continue;
2933             }
2934         }
2935
2936       /* Perform error checking that did not get done in
2937          grokdeclarator.  */
2938       if (TREE_CODE (type) == FUNCTION_TYPE)
2939         {
2940           error ("field %q+D invalidly declared function type", x);
2941           type = build_pointer_type (type);
2942           TREE_TYPE (x) = type;
2943         }
2944       else if (TREE_CODE (type) == METHOD_TYPE)
2945         {
2946           error ("field %q+D invalidly declared method type", x);
2947           type = build_pointer_type (type);
2948           TREE_TYPE (x) = type;
2949         }
2950
2951       if (type == error_mark_node)
2952         continue;
2953
2954       if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
2955         continue;
2956
2957       /* Now it can only be a FIELD_DECL.  */
2958
2959       if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
2960         CLASSTYPE_NON_AGGREGATE (t) = 1;
2961
2962       /* If this is of reference type, check if it needs an init.  */
2963       if (TREE_CODE (type) == REFERENCE_TYPE)
2964         {
2965           CLASSTYPE_NON_POD_P (t) = 1;
2966           if (DECL_INITIAL (x) == NULL_TREE)
2967             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
2968
2969           /* ARM $12.6.2: [A member initializer list] (or, for an
2970              aggregate, initialization by a brace-enclosed list) is the
2971              only way to initialize nonstatic const and reference
2972              members.  */
2973           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
2974         }
2975
2976       type = strip_array_types (type);
2977
2978       if (TYPE_PACKED (t))
2979         {
2980           if (!pod_type_p (type) && !TYPE_PACKED (type))
2981             {
2982               warning
2983                 (0,
2984                  "ignoring packed attribute because of unpacked non-POD field %q+#D",
2985                  x);
2986               cant_pack = 1;
2987             }
2988           else if (DECL_C_BIT_FIELD (x)
2989                    || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
2990             DECL_PACKED (x) = 1;
2991         }
2992
2993       if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
2994         /* We don't treat zero-width bitfields as making a class
2995            non-empty.  */
2996         ;
2997       else
2998         {
2999           /* The class is non-empty.  */
3000           CLASSTYPE_EMPTY_P (t) = 0;
3001           /* The class is not even nearly empty.  */
3002           CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3003           /* If one of the data members contains an empty class,
3004              so does T.  */
3005           if (CLASS_TYPE_P (type)
3006               && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3007             CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
3008         }
3009
3010       /* This is used by -Weffc++ (see below). Warn only for pointers
3011          to members which might hold dynamic memory. So do not warn
3012          for pointers to functions or pointers to members.  */
3013       if (TYPE_PTR_P (type)
3014           && !TYPE_PTRFN_P (type)
3015           && !TYPE_PTR_TO_MEMBER_P (type))
3016         has_pointers = true;
3017
3018       if (CLASS_TYPE_P (type))
3019         {
3020           if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3021             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3022           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3023             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3024         }
3025
3026       if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3027         CLASSTYPE_HAS_MUTABLE (t) = 1;
3028
3029       if (! pod_type_p (type))
3030         /* DR 148 now allows pointers to members (which are POD themselves),
3031            to be allowed in POD structs.  */
3032         CLASSTYPE_NON_POD_P (t) = 1;
3033
3034       if (! zero_init_p (type))
3035         CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3036
3037       /* If any field is const, the structure type is pseudo-const.  */
3038       if (CP_TYPE_CONST_P (type))
3039         {
3040           C_TYPE_FIELDS_READONLY (t) = 1;
3041           if (DECL_INITIAL (x) == NULL_TREE)
3042             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3043
3044           /* ARM $12.6.2: [A member initializer list] (or, for an
3045              aggregate, initialization by a brace-enclosed list) is the
3046              only way to initialize nonstatic const and reference
3047              members.  */
3048           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3049         }
3050       /* A field that is pseudo-const makes the structure likewise.  */
3051       else if (CLASS_TYPE_P (type))
3052         {
3053           C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3054           SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3055             CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3056             | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3057         }
3058
3059       /* Core issue 80: A nonstatic data member is required to have a
3060          different name from the class iff the class has a
3061          user-declared constructor.  */
3062       if (constructor_name_p (DECL_NAME (x), t)
3063           && TYPE_HAS_USER_CONSTRUCTOR (t))
3064         permerror (input_location, "field %q+#D with same name as class", x);
3065
3066       /* We set DECL_C_BIT_FIELD in grokbitfield.
3067          If the type and width are valid, we'll also set DECL_BIT_FIELD.  */
3068       if (! DECL_C_BIT_FIELD (x) || ! check_bitfield_decl (x))
3069         check_field_decl (x, t,
3070                           cant_have_const_ctor_p,
3071                           no_const_asn_ref_p,
3072                           &any_default_members);
3073     }
3074
3075   /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3076      it should also define a copy constructor and an assignment operator to
3077      implement the correct copy semantic (deep vs shallow, etc.). As it is
3078      not feasible to check whether the constructors do allocate dynamic memory
3079      and store it within members, we approximate the warning like this:
3080
3081      -- Warn only if there are members which are pointers
3082      -- Warn only if there is a non-trivial constructor (otherwise,
3083         there cannot be memory allocated).
3084      -- Warn only if there is a non-trivial destructor. We assume that the
3085         user at least implemented the cleanup correctly, and a destructor
3086         is needed to free dynamic memory.
3087
3088      This seems enough for practical purposes.  */
3089   if (warn_ecpp
3090       && has_pointers
3091       && TYPE_HAS_USER_CONSTRUCTOR (t)
3092       && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
3093       && !(TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3094     {
3095       warning (OPT_Weffc__, "%q#T has pointer data members", t);
3096
3097       if (! TYPE_HAS_INIT_REF (t))
3098         {
3099           warning (OPT_Weffc__,
3100                    "  but does not override %<%T(const %T&)%>", t, t);
3101           if (!TYPE_HAS_ASSIGN_REF (t))
3102             warning (OPT_Weffc__, "  or %<operator=(const %T&)%>", t);
3103         }
3104       else if (! TYPE_HAS_ASSIGN_REF (t))
3105         warning (OPT_Weffc__,
3106                  "  but does not override %<operator=(const %T&)%>", t);
3107     }
3108
3109   /* If any of the fields couldn't be packed, unset TYPE_PACKED.  */
3110   if (cant_pack)
3111     TYPE_PACKED (t) = 0;
3112
3113   /* Check anonymous struct/anonymous union fields.  */
3114   finish_struct_anon (t);
3115
3116   /* We've built up the list of access declarations in reverse order.
3117      Fix that now.  */
3118   *access_decls = nreverse (*access_decls);
3119 }
3120
3121 /* If TYPE is an empty class type, records its OFFSET in the table of
3122    OFFSETS.  */
3123
3124 static int
3125 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3126 {
3127   splay_tree_node n;
3128
3129   if (!is_empty_class (type))
3130     return 0;
3131
3132   /* Record the location of this empty object in OFFSETS.  */
3133   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3134   if (!n)
3135     n = splay_tree_insert (offsets,
3136                            (splay_tree_key) offset,
3137                            (splay_tree_value) NULL_TREE);
3138   n->value = ((splay_tree_value)
3139               tree_cons (NULL_TREE,
3140                          type,
3141                          (tree) n->value));
3142
3143   return 0;
3144 }
3145
3146 /* Returns nonzero if TYPE is an empty class type and there is
3147    already an entry in OFFSETS for the same TYPE as the same OFFSET.  */
3148
3149 static int
3150 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3151 {
3152   splay_tree_node n;
3153   tree t;
3154
3155   if (!is_empty_class (type))
3156     return 0;
3157
3158   /* Record the location of this empty object in OFFSETS.  */
3159   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3160   if (!n)
3161     return 0;
3162
3163   for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3164     if (same_type_p (TREE_VALUE (t), type))
3165       return 1;
3166
3167   return 0;
3168 }
3169
3170 /* Walk through all the subobjects of TYPE (located at OFFSET).  Call
3171    F for every subobject, passing it the type, offset, and table of
3172    OFFSETS.  If VBASES_P is one, then virtual non-primary bases should
3173    be traversed.
3174
3175    If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3176    than MAX_OFFSET will not be walked.
3177
3178    If F returns a nonzero value, the traversal ceases, and that value
3179    is returned.  Otherwise, returns zero.  */
3180
3181 static int
3182 walk_subobject_offsets (tree type,
3183                         subobject_offset_fn f,
3184                         tree offset,
3185                         splay_tree offsets,
3186                         tree max_offset,
3187                         int vbases_p)
3188 {
3189   int r = 0;
3190   tree type_binfo = NULL_TREE;
3191
3192   /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3193      stop.  */
3194   if (max_offset && INT_CST_LT (max_offset, offset))
3195     return 0;
3196
3197   if (type == error_mark_node)
3198     return 0;
3199
3200   if (!TYPE_P (type))
3201     {
3202       if (abi_version_at_least (2))
3203         type_binfo = type;
3204       type = BINFO_TYPE (type);
3205     }
3206
3207   if (CLASS_TYPE_P (type))
3208     {
3209       tree field;
3210       tree binfo;
3211       int i;
3212
3213       /* Avoid recursing into objects that are not interesting.  */
3214       if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3215         return 0;
3216
3217       /* Record the location of TYPE.  */
3218       r = (*f) (type, offset, offsets);
3219       if (r)
3220         return r;
3221
3222       /* Iterate through the direct base classes of TYPE.  */
3223       if (!type_binfo)
3224         type_binfo = TYPE_BINFO (type);
3225       for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, binfo); i++)
3226         {
3227           tree binfo_offset;
3228
3229           if (abi_version_at_least (2)
3230               && BINFO_VIRTUAL_P (binfo))
3231             continue;
3232
3233           if (!vbases_p
3234               && BINFO_VIRTUAL_P (binfo)
3235               && !BINFO_PRIMARY_P (binfo))
3236             continue;
3237
3238           if (!abi_version_at_least (2))
3239             binfo_offset = size_binop (PLUS_EXPR,
3240                                        offset,
3241                                        BINFO_OFFSET (binfo));
3242           else
3243             {
3244               tree orig_binfo;
3245               /* We cannot rely on BINFO_OFFSET being set for the base
3246                  class yet, but the offsets for direct non-virtual
3247                  bases can be calculated by going back to the TYPE.  */
3248               orig_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
3249               binfo_offset = size_binop (PLUS_EXPR,
3250                                          offset,
3251                                          BINFO_OFFSET (orig_binfo));
3252             }
3253
3254           r = walk_subobject_offsets (binfo,
3255                                       f,
3256                                       binfo_offset,
3257                                       offsets,
3258                                       max_offset,
3259                                       (abi_version_at_least (2)
3260                                        ? /*vbases_p=*/0 : vbases_p));
3261           if (r)
3262             return r;
3263         }
3264
3265       if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type))
3266         {
3267           unsigned ix;
3268           VEC(tree,gc) *vbases;
3269
3270           /* Iterate through the virtual base classes of TYPE.  In G++
3271              3.2, we included virtual bases in the direct base class
3272              loop above, which results in incorrect results; the
3273              correct offsets for virtual bases are only known when
3274              working with the most derived type.  */
3275           if (vbases_p)
3276             for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0;
3277                  VEC_iterate (tree, vbases, ix, binfo); ix++)
3278               {
3279                 r = walk_subobject_offsets (binfo,
3280                                             f,
3281                                             size_binop (PLUS_EXPR,
3282                                                         offset,
3283                                                         BINFO_OFFSET (binfo)),
3284                                             offsets,
3285                                             max_offset,
3286                                             /*vbases_p=*/0);
3287                 if (r)
3288                   return r;
3289               }
3290           else
3291             {
3292               /* We still have to walk the primary base, if it is
3293                  virtual.  (If it is non-virtual, then it was walked
3294                  above.)  */
3295               tree vbase = get_primary_binfo (type_binfo);
3296
3297               if (vbase && BINFO_VIRTUAL_P (vbase)
3298                   && BINFO_PRIMARY_P (vbase)
3299                   && BINFO_INHERITANCE_CHAIN (vbase) == type_binfo)
3300                 {
3301                   r = (walk_subobject_offsets
3302                        (vbase, f, offset,
3303                         offsets, max_offset, /*vbases_p=*/0));
3304                   if (r)
3305                     return r;
3306                 }
3307             }
3308         }
3309
3310       /* Iterate through the fields of TYPE.  */
3311       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3312         if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3313           {
3314             tree field_offset;
3315
3316             if (abi_version_at_least (2))
3317               field_offset = byte_position (field);
3318             else
3319               /* In G++ 3.2, DECL_FIELD_OFFSET was used.  */
3320               field_offset = DECL_FIELD_OFFSET (field);
3321
3322             r = walk_subobject_offsets (TREE_TYPE (field),
3323                                         f,
3324                                         size_binop (PLUS_EXPR,
3325                                                     offset,
3326                                                     field_offset),
3327                                         offsets,
3328                                         max_offset,
3329                                         /*vbases_p=*/1);
3330             if (r)
3331               return r;
3332           }
3333     }
3334   else if (TREE_CODE (type) == ARRAY_TYPE)
3335     {
3336       tree element_type = strip_array_types (type);
3337       tree domain = TYPE_DOMAIN (type);
3338       tree index;
3339
3340       /* Avoid recursing into objects that are not interesting.  */
3341       if (!CLASS_TYPE_P (element_type)
3342           || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3343         return 0;
3344
3345       /* Step through each of the elements in the array.  */
3346       for (index = size_zero_node;
3347            /* G++ 3.2 had an off-by-one error here.  */
3348            (abi_version_at_least (2)
3349             ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3350             : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3351            index = size_binop (PLUS_EXPR, index, size_one_node))
3352         {
3353           r = walk_subobject_offsets (TREE_TYPE (type),
3354                                       f,
3355                                       offset,
3356                                       offsets,
3357                                       max_offset,
3358                                       /*vbases_p=*/1);
3359           if (r)
3360             return r;
3361           offset = size_binop (PLUS_EXPR, offset,
3362                                TYPE_SIZE_UNIT (TREE_TYPE (type)));
3363           /* If this new OFFSET is bigger than the MAX_OFFSET, then
3364              there's no point in iterating through the remaining
3365              elements of the array.  */
3366           if (max_offset && INT_CST_LT (max_offset, offset))
3367             break;
3368         }
3369     }
3370
3371   return 0;
3372 }
3373
3374 /* Record all of the empty subobjects of TYPE (either a type or a
3375    binfo).  If IS_DATA_MEMBER is true, then a non-static data member
3376    is being placed at OFFSET; otherwise, it is a base class that is
3377    being placed at OFFSET.  */
3378
3379 static void
3380 record_subobject_offsets (tree type,
3381                           tree offset,
3382                           splay_tree offsets,
3383                           bool is_data_member)
3384 {
3385   tree max_offset;
3386   /* If recording subobjects for a non-static data member or a
3387      non-empty base class , we do not need to record offsets beyond
3388      the size of the biggest empty class.  Additional data members
3389      will go at the end of the class.  Additional base classes will go
3390      either at offset zero (if empty, in which case they cannot
3391      overlap with offsets past the size of the biggest empty class) or
3392      at the end of the class.
3393
3394      However, if we are placing an empty base class, then we must record
3395      all offsets, as either the empty class is at offset zero (where
3396      other empty classes might later be placed) or at the end of the
3397      class (where other objects might then be placed, so other empty
3398      subobjects might later overlap).  */
3399   if (is_data_member
3400       || !is_empty_class (BINFO_TYPE (type)))
3401     max_offset = sizeof_biggest_empty_class;
3402   else
3403     max_offset = NULL_TREE;
3404   walk_subobject_offsets (type, record_subobject_offset, offset,
3405                           offsets, max_offset, is_data_member);
3406 }
3407
3408 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3409    OFFSET) conflict with entries in OFFSETS.  If VBASES_P is nonzero,
3410    virtual bases of TYPE are examined.  */
3411
3412 static int
3413 layout_conflict_p (tree type,
3414                    tree offset,
3415                    splay_tree offsets,
3416                    int vbases_p)
3417 {
3418   splay_tree_node max_node;
3419
3420   /* Get the node in OFFSETS that indicates the maximum offset where
3421      an empty subobject is located.  */
3422   max_node = splay_tree_max (offsets);
3423   /* If there aren't any empty subobjects, then there's no point in
3424      performing this check.  */
3425   if (!max_node)
3426     return 0;
3427
3428   return walk_subobject_offsets (type, check_subobject_offset, offset,
3429                                  offsets, (tree) (max_node->key),
3430                                  vbases_p);
3431 }
3432
3433 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3434    non-static data member of the type indicated by RLI.  BINFO is the
3435    binfo corresponding to the base subobject, OFFSETS maps offsets to
3436    types already located at those offsets.  This function determines
3437    the position of the DECL.  */
3438
3439 static void
3440 layout_nonempty_base_or_field (record_layout_info rli,
3441                                tree decl,
3442                                tree binfo,
3443                                splay_tree offsets)
3444 {
3445   tree offset = NULL_TREE;
3446   bool field_p;
3447   tree type;
3448
3449   if (binfo)
3450     {
3451       /* For the purposes of determining layout conflicts, we want to
3452          use the class type of BINFO; TREE_TYPE (DECL) will be the
3453          CLASSTYPE_AS_BASE version, which does not contain entries for
3454          zero-sized bases.  */
3455       type = TREE_TYPE (binfo);
3456       field_p = false;
3457     }
3458   else
3459     {
3460       type = TREE_TYPE (decl);
3461       field_p = true;
3462     }
3463
3464   /* Try to place the field.  It may take more than one try if we have
3465      a hard time placing the field without putting two objects of the
3466      same type at the same address.  */
3467   while (1)
3468     {
3469       struct record_layout_info_s old_rli = *rli;
3470
3471       /* Place this field.  */
3472       place_field (rli, decl);
3473       offset = byte_position (decl);
3474
3475       /* We have to check to see whether or not there is already
3476          something of the same type at the offset we're about to use.
3477          For example, consider:
3478
3479            struct S {};
3480            struct T : public S { int i; };
3481            struct U : public S, public T {};
3482
3483          Here, we put S at offset zero in U.  Then, we can't put T at
3484          offset zero -- its S component would be at the same address
3485          as the S we already allocated.  So, we have to skip ahead.
3486          Since all data members, including those whose type is an
3487          empty class, have nonzero size, any overlap can happen only
3488          with a direct or indirect base-class -- it can't happen with
3489          a data member.  */
3490       /* In a union, overlap is permitted; all members are placed at
3491          offset zero.  */
3492       if (TREE_CODE (rli->t) == UNION_TYPE)
3493         break;
3494       /* G++ 3.2 did not check for overlaps when placing a non-empty
3495          virtual base.  */
3496       if (!abi_version_at_least (2) && binfo && BINFO_VIRTUAL_P (binfo))
3497         break;
3498       if (layout_conflict_p (field_p ? type : binfo, offset,
3499                              offsets, field_p))
3500         {
3501           /* Strip off the size allocated to this field.  That puts us
3502              at the first place we could have put the field with
3503              proper alignment.  */
3504           *rli = old_rli;
3505
3506           /* Bump up by the alignment required for the type.  */
3507           rli->bitpos
3508             = size_binop (PLUS_EXPR, rli->bitpos,
3509                           bitsize_int (binfo
3510                                        ? CLASSTYPE_ALIGN (type)
3511                                        : TYPE_ALIGN (type)));
3512           normalize_rli (rli);
3513         }
3514       else
3515         /* There was no conflict.  We're done laying out this field.  */
3516         break;
3517     }
3518
3519   /* Now that we know where it will be placed, update its
3520      BINFO_OFFSET.  */
3521   if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3522     /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3523        this point because their BINFO_OFFSET is copied from another
3524        hierarchy.  Therefore, we may not need to add the entire
3525        OFFSET.  */
3526     propagate_binfo_offsets (binfo,
3527                              size_diffop (convert (ssizetype, offset),
3528                                           convert (ssizetype,
3529                                                    BINFO_OFFSET (binfo))));
3530 }
3531
3532 /* Returns true if TYPE is empty and OFFSET is nonzero.  */
3533
3534 static int
3535 empty_base_at_nonzero_offset_p (tree type,
3536                                 tree offset,
3537                                 splay_tree offsets ATTRIBUTE_UNUSED)
3538 {
3539   return is_empty_class (type) && !integer_zerop (offset);
3540 }
3541
3542 /* Layout the empty base BINFO.  EOC indicates the byte currently just
3543    past the end of the class, and should be correctly aligned for a
3544    class of the type indicated by BINFO; OFFSETS gives the offsets of
3545    the empty bases allocated so far. T is the most derived
3546    type.  Return nonzero iff we added it at the end.  */
3547
3548 static bool
3549 layout_empty_base (record_layout_info rli, tree binfo,
3550                    tree eoc, splay_tree offsets)
3551 {
3552   tree alignment;
3553   tree basetype = BINFO_TYPE (binfo);
3554   bool atend = false;
3555
3556   /* This routine should only be used for empty classes.  */
3557   gcc_assert (is_empty_class (basetype));
3558   alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3559
3560   if (!integer_zerop (BINFO_OFFSET (binfo)))
3561     {
3562       if (abi_version_at_least (2))
3563         propagate_binfo_offsets
3564           (binfo, size_diffop (size_zero_node, BINFO_OFFSET (binfo)));
3565       else
3566         warning (OPT_Wabi,
3567                  "offset of empty base %qT may not be ABI-compliant and may"
3568                  "change in a future version of GCC",
3569                  BINFO_TYPE (binfo));
3570     }
3571
3572   /* This is an empty base class.  We first try to put it at offset
3573      zero.  */
3574   if (layout_conflict_p (binfo,
3575                          BINFO_OFFSET (binfo),
3576                          offsets,
3577                          /*vbases_p=*/0))
3578     {
3579       /* That didn't work.  Now, we move forward from the next
3580          available spot in the class.  */
3581       atend = true;
3582       propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3583       while (1)
3584         {
3585           if (!layout_conflict_p (binfo,
3586                                   BINFO_OFFSET (binfo),
3587                                   offsets,
3588                                   /*vbases_p=*/0))
3589             /* We finally found a spot where there's no overlap.  */
3590             break;
3591
3592           /* There's overlap here, too.  Bump along to the next spot.  */
3593           propagate_binfo_offsets (binfo, alignment);
3594         }
3595     }
3596
3597   if (CLASSTYPE_USER_ALIGN (basetype))
3598     {
3599       rli->record_align = MAX (rli->record_align, CLASSTYPE_ALIGN (basetype));
3600       if (warn_packed)
3601         rli->unpacked_align = MAX (rli->unpacked_align, CLASSTYPE_ALIGN (basetype));
3602       TYPE_USER_ALIGN (rli->t) = 1;
3603     }
3604
3605   return atend;
3606 }
3607
3608 /* Layout the base given by BINFO in the class indicated by RLI.
3609    *BASE_ALIGN is a running maximum of the alignments of
3610    any base class.  OFFSETS gives the location of empty base
3611    subobjects.  T is the most derived type.  Return nonzero if the new
3612    object cannot be nearly-empty.  A new FIELD_DECL is inserted at
3613    *NEXT_FIELD, unless BINFO is for an empty base class.
3614
3615    Returns the location at which the next field should be inserted.  */
3616
3617 static tree *
3618 build_base_field (record_layout_info rli, tree binfo,
3619                   splay_tree offsets, tree *next_field)
3620 {
3621   tree t = rli->t;
3622   tree basetype = BINFO_TYPE (binfo);
3623
3624   if (!COMPLETE_TYPE_P (basetype))
3625     /* This error is now reported in xref_tag, thus giving better
3626        location information.  */
3627     return next_field;
3628
3629   /* Place the base class.  */
3630   if (!is_empty_class (basetype))
3631     {
3632       tree decl;
3633
3634       /* The containing class is non-empty because it has a non-empty
3635          base class.  */
3636       CLASSTYPE_EMPTY_P (t) = 0;
3637
3638       /* Create the FIELD_DECL.  */
3639       decl = build_decl (FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3640       DECL_ARTIFICIAL (decl) = 1;
3641       DECL_IGNORED_P (decl) = 1;
3642       DECL_FIELD_CONTEXT (decl) = t;
3643       if (CLASSTYPE_AS_BASE (basetype))
3644         {
3645           DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3646           DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3647           DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3648           DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3649           DECL_MODE (decl) = TYPE_MODE (basetype);
3650           DECL_FIELD_IS_BASE (decl) = 1;
3651
3652           /* Try to place the field.  It may take more than one try if we
3653              have a hard time placing the field without putting two
3654              objects of the same type at the same address.  */
3655           layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3656           /* Add the new FIELD_DECL to the list of fields for T.  */
3657           TREE_CHAIN (decl) = *next_field;
3658           *next_field = decl;
3659           next_field = &TREE_CHAIN (decl);
3660         }
3661     }
3662   else
3663     {
3664       tree eoc;
3665       bool atend;
3666
3667       /* On some platforms (ARM), even empty classes will not be
3668          byte-aligned.  */
3669       eoc = round_up (rli_size_unit_so_far (rli),
3670                       CLASSTYPE_ALIGN_UNIT (basetype));
3671       atend = layout_empty_base (rli, binfo, eoc, offsets);
3672       /* A nearly-empty class "has no proper base class that is empty,
3673          not morally virtual, and at an offset other than zero."  */
3674       if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3675         {
3676           if (atend)
3677             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3678           /* The check above (used in G++ 3.2) is insufficient because
3679              an empty class placed at offset zero might itself have an
3680              empty base at a nonzero offset.  */
3681           else if (walk_subobject_offsets (basetype,
3682                                            empty_base_at_nonzero_offset_p,
3683                                            size_zero_node,
3684                                            /*offsets=*/NULL,
3685                                            /*max_offset=*/NULL_TREE,
3686                                            /*vbases_p=*/true))
3687             {
3688               if (abi_version_at_least (2))
3689                 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3690               else
3691                 warning (OPT_Wabi,
3692                          "class %qT will be considered nearly empty in a "
3693                          "future version of GCC", t);
3694             }
3695         }
3696
3697       /* We do not create a FIELD_DECL for empty base classes because
3698          it might overlap some other field.  We want to be able to
3699          create CONSTRUCTORs for the class by iterating over the
3700          FIELD_DECLs, and the back end does not handle overlapping
3701          FIELD_DECLs.  */
3702
3703       /* An empty virtual base causes a class to be non-empty
3704          -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3705          here because that was already done when the virtual table
3706          pointer was created.  */
3707     }
3708
3709   /* Record the offsets of BINFO and its base subobjects.  */
3710   record_subobject_offsets (binfo,
3711                             BINFO_OFFSET (binfo),
3712                             offsets,
3713                             /*is_data_member=*/false);
3714
3715   return next_field;
3716 }
3717
3718 /* Layout all of the non-virtual base classes.  Record empty
3719    subobjects in OFFSETS.  T is the most derived type.  Return nonzero
3720    if the type cannot be nearly empty.  The fields created
3721    corresponding to the base classes will be inserted at
3722    *NEXT_FIELD.  */
3723
3724 static void
3725 build_base_fields (record_layout_info rli,
3726                    splay_tree offsets, tree *next_field)
3727 {
3728   /* Chain to hold all the new FIELD_DECLs which stand in for base class
3729      subobjects.  */
3730   tree t = rli->t;
3731   int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
3732   int i;
3733
3734   /* The primary base class is always allocated first.  */
3735   if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3736     next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3737                                    offsets, next_field);
3738
3739   /* Now allocate the rest of the bases.  */
3740   for (i = 0; i < n_baseclasses; ++i)
3741     {
3742       tree base_binfo;
3743
3744       base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
3745
3746       /* The primary base was already allocated above, so we don't
3747          need to allocate it again here.  */
3748       if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3749         continue;
3750
3751       /* Virtual bases are added at the end (a primary virtual base
3752          will have already been added).  */
3753       if (BINFO_VIRTUAL_P (base_binfo))
3754         continue;
3755
3756       next_field = build_base_field (rli, base_binfo,
3757                                      offsets, next_field);
3758     }
3759 }
3760
3761 /* Go through the TYPE_METHODS of T issuing any appropriate
3762    diagnostics, figuring out which methods override which other
3763    methods, and so forth.  */
3764
3765 static void
3766 check_methods (tree t)
3767 {
3768   tree x;
3769
3770   for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3771     {
3772       check_for_override (x, t);
3773       if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3774         error ("initializer specified for non-virtual method %q+D", x);
3775       /* The name of the field is the original field name
3776          Save this in auxiliary field for later overloading.  */
3777       if (DECL_VINDEX (x))
3778         {
3779           TYPE_POLYMORPHIC_P (t) = 1;
3780           if (DECL_PURE_VIRTUAL_P (x))
3781             VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
3782         }
3783       /* All user-provided destructors are non-trivial.  */
3784       if (DECL_DESTRUCTOR_P (x) && !DECL_DEFAULTED_FN (x))
3785         TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 1;
3786     }
3787 }
3788
3789 /* FN is a constructor or destructor.  Clone the declaration to create
3790    a specialized in-charge or not-in-charge version, as indicated by
3791    NAME.  */
3792
3793 static tree
3794 build_clone (tree fn, tree name)
3795 {
3796   tree parms;
3797   tree clone;
3798
3799   /* Copy the function.  */
3800   clone = copy_decl (fn);
3801   /* Remember where this function came from.  */
3802   DECL_CLONED_FUNCTION (clone) = fn;
3803   DECL_ABSTRACT_ORIGIN (clone) = fn;
3804   /* Reset the function name.  */
3805   DECL_NAME (clone) = name;
3806   SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3807   /* There's no pending inline data for this function.  */
3808   DECL_PENDING_INLINE_INFO (clone) = NULL;
3809   DECL_PENDING_INLINE_P (clone) = 0;
3810   /* And it hasn't yet been deferred.  */
3811   DECL_DEFERRED_FN (clone) = 0;
3812
3813   /* The base-class destructor is not virtual.  */
3814   if (name == base_dtor_identifier)
3815     {
3816       DECL_VIRTUAL_P (clone) = 0;
3817       if (TREE_CODE (clone) != TEMPLATE_DECL)
3818         DECL_VINDEX (clone) = NULL_TREE;
3819     }
3820
3821   /* If there was an in-charge parameter, drop it from the function
3822      type.  */
3823   if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3824     {
3825       tree basetype;
3826       tree parmtypes;
3827       tree exceptions;
3828
3829       exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3830       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3831       parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
3832       /* Skip the `this' parameter.  */
3833       parmtypes = TREE_CHAIN (parmtypes);
3834       /* Skip the in-charge parameter.  */
3835       parmtypes = TREE_CHAIN (parmtypes);
3836       /* And the VTT parm, in a complete [cd]tor.  */
3837       if (DECL_HAS_VTT_PARM_P (fn)
3838           && ! DECL_NEEDS_VTT_PARM_P (clone))
3839         parmtypes = TREE_CHAIN (parmtypes);
3840        /* If this is subobject constructor or destructor, add the vtt
3841          parameter.  */
3842       TREE_TYPE (clone)
3843         = build_method_type_directly (basetype,
3844                                       TREE_TYPE (TREE_TYPE (clone)),
3845                                       parmtypes);
3846       if (exceptions)
3847         TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
3848                                                      exceptions);
3849       TREE_TYPE (clone)
3850         = cp_build_type_attribute_variant (TREE_TYPE (clone),
3851                                            TYPE_ATTRIBUTES (TREE_TYPE (fn)));
3852     }
3853
3854   /* Copy the function parameters.  But, DECL_ARGUMENTS on a TEMPLATE_DECL
3855      aren't function parameters; those are the template parameters.  */
3856   if (TREE_CODE (clone) != TEMPLATE_DECL)
3857     {
3858       DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
3859       /* Remove the in-charge parameter.  */
3860       if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3861         {
3862           TREE_CHAIN (DECL_ARGUMENTS (clone))
3863             = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3864           DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
3865         }
3866       /* And the VTT parm, in a complete [cd]tor.  */
3867       if (DECL_HAS_VTT_PARM_P (fn))
3868         {
3869           if (DECL_NEEDS_VTT_PARM_P (clone))
3870             DECL_HAS_VTT_PARM_P (clone) = 1;
3871           else
3872             {
3873               TREE_CHAIN (DECL_ARGUMENTS (clone))
3874                 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3875               DECL_HAS_VTT_PARM_P (clone) = 0;
3876             }
3877         }
3878
3879       for (parms = DECL_ARGUMENTS (clone); parms; parms = TREE_CHAIN (parms))
3880         {
3881           DECL_CONTEXT (parms) = clone;
3882           cxx_dup_lang_specific_decl (parms);
3883         }
3884     }
3885
3886   /* Create the RTL for this function.  */
3887   SET_DECL_RTL (clone, NULL_RTX);
3888   rest_of_decl_compilation (clone, /*top_level=*/1, at_eof);
3889
3890   /* Make it easy to find the CLONE given the FN.  */
3891   TREE_CHAIN (clone) = TREE_CHAIN (fn);
3892   TREE_CHAIN (fn) = clone;
3893
3894   /* If this is a template, handle the DECL_TEMPLATE_RESULT as well.  */
3895   if (TREE_CODE (clone) == TEMPLATE_DECL)
3896     {
3897       tree result;
3898
3899       DECL_TEMPLATE_RESULT (clone)
3900         = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3901       result = DECL_TEMPLATE_RESULT (clone);
3902       DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3903       DECL_TI_TEMPLATE (result) = clone;
3904     }
3905   else if (pch_file)
3906     note_decl_for_pch (clone);
3907
3908   return clone;
3909 }
3910
3911 /* Produce declarations for all appropriate clones of FN.  If
3912    UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
3913    CLASTYPE_METHOD_VEC as well.  */
3914
3915 void
3916 clone_function_decl (tree fn, int update_method_vec_p)
3917 {
3918   tree clone;
3919
3920   /* Avoid inappropriate cloning.  */
3921   if (TREE_CHAIN (fn)
3922       && DECL_CLONED_FUNCTION (TREE_CHAIN (fn)))
3923     return;
3924
3925   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
3926     {
3927       /* For each constructor, we need two variants: an in-charge version
3928          and a not-in-charge version.  */
3929       clone = build_clone (fn, complete_ctor_identifier);
3930       if (update_method_vec_p)
3931         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3932       clone = build_clone (fn, base_ctor_identifier);
3933       if (update_method_vec_p)
3934         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3935     }
3936   else
3937     {
3938       gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn));
3939
3940       /* For each destructor, we need three variants: an in-charge
3941          version, a not-in-charge version, and an in-charge deleting
3942          version.  We clone the deleting version first because that
3943          means it will go second on the TYPE_METHODS list -- and that
3944          corresponds to the correct layout order in the virtual
3945          function table.
3946
3947          For a non-virtual destructor, we do not build a deleting
3948          destructor.  */
3949       if (DECL_VIRTUAL_P (fn))
3950         {
3951           clone = build_clone (fn, deleting_dtor_identifier);
3952           if (update_method_vec_p)
3953             add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3954         }
3955       clone = build_clone (fn, complete_dtor_identifier);
3956       if (update_method_vec_p)
3957         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3958       clone = build_clone (fn, base_dtor_identifier);
3959       if (update_method_vec_p)
3960         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3961     }
3962
3963   /* Note that this is an abstract function that is never emitted.  */
3964   DECL_ABSTRACT (fn) = 1;
3965 }
3966
3967 /* DECL is an in charge constructor, which is being defined. This will
3968    have had an in class declaration, from whence clones were
3969    declared. An out-of-class definition can specify additional default
3970    arguments. As it is the clones that are involved in overload
3971    resolution, we must propagate the information from the DECL to its
3972    clones.  */
3973
3974 void
3975 adjust_clone_args (tree decl)
3976 {
3977   tree clone;
3978
3979   for (clone = TREE_CHAIN (decl); clone && DECL_CLONED_FUNCTION (clone);
3980        clone = TREE_CHAIN (clone))
3981     {
3982       tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone));
3983       tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
3984       tree decl_parms, clone_parms;
3985
3986       clone_parms = orig_clone_parms;
3987
3988       /* Skip the 'this' parameter.  */
3989       orig_clone_parms = TREE_CHAIN (orig_clone_parms);
3990       orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3991
3992       if (DECL_HAS_IN_CHARGE_PARM_P (decl))
3993         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3994       if (DECL_HAS_VTT_PARM_P (decl))
3995         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3996
3997       clone_parms = orig_clone_parms;
3998       if (DECL_HAS_VTT_PARM_P (clone))
3999         clone_parms = TREE_CHAIN (clone_parms);
4000
4001       for (decl_parms = orig_decl_parms; decl_parms;
4002            decl_parms = TREE_CHAIN (decl_parms),
4003              clone_parms = TREE_CHAIN (clone_parms))
4004         {
4005           gcc_assert (same_type_p (TREE_TYPE (decl_parms),
4006                                    TREE_TYPE (clone_parms)));
4007
4008           if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
4009             {
4010               /* A default parameter has been added. Adjust the
4011                  clone's parameters.  */
4012               tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
4013               tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
4014               tree type;
4015
4016               clone_parms = orig_decl_parms;
4017
4018               if (DECL_HAS_VTT_PARM_P (clone))
4019                 {
4020                   clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
4021                                            TREE_VALUE (orig_clone_parms),
4022                                            clone_parms);
4023                   TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
4024                 }
4025               type = build_method_type_directly (basetype,
4026                                                  TREE_TYPE (TREE_TYPE (clone)),
4027                                                  clone_parms);
4028               if (exceptions)
4029                 type = build_exception_variant (type, exceptions);
4030               TREE_TYPE (clone) = type;
4031
4032               clone_parms = NULL_TREE;
4033               break;
4034             }
4035         }
4036       gcc_assert (!clone_parms);
4037     }
4038 }
4039
4040 /* For each of the constructors and destructors in T, create an
4041    in-charge and not-in-charge variant.  */
4042
4043 static void
4044 clone_constructors_and_destructors (tree t)
4045 {
4046   tree fns;
4047
4048   /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4049      out now.  */
4050   if (!CLASSTYPE_METHOD_VEC (t))
4051     return;
4052
4053   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4054     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4055   for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4056     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4057 }
4058
4059 /* Returns true iff class T has a user-defined constructor other than
4060    the default constructor.  */
4061
4062 bool
4063 type_has_user_nondefault_constructor (tree t)
4064 {
4065   tree fns;
4066
4067   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4068     return false;
4069
4070   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4071     {
4072       tree fn = OVL_CURRENT (fns);
4073       if (!DECL_ARTIFICIAL (fn)
4074           && (TREE_CODE (fn) == TEMPLATE_DECL
4075               || (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn))
4076                   != NULL_TREE)))
4077         return true;
4078     }
4079
4080   return false;
4081 }
4082
4083 /* Returns true iff FN is a user-provided function, i.e. user-declared
4084    and not defaulted at its first declaration.  */
4085
4086 static bool
4087 user_provided_p (tree fn)
4088 {
4089   if (TREE_CODE (fn) == TEMPLATE_DECL)
4090     return true;
4091   else
4092     return (!DECL_ARTIFICIAL (fn)
4093             && !(DECL_DEFAULTED_FN (fn)
4094                  && DECL_INITIALIZED_IN_CLASS_P (fn)));
4095 }
4096
4097 /* Returns true iff class T has a user-provided constructor.  */
4098
4099 bool
4100 type_has_user_provided_constructor (tree t)
4101 {
4102   tree fns;
4103
4104   if (!CLASS_TYPE_P (t))
4105     return false;
4106
4107   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4108     return false;
4109
4110   /* This can happen in error cases; avoid crashing.  */
4111   if (!CLASSTYPE_METHOD_VEC (t))
4112     return false;
4113
4114   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4115     if (user_provided_p (OVL_CURRENT (fns)))
4116       return true;
4117
4118   return false;
4119 }
4120
4121 /* Returns true iff class T has a user-provided default constructor.  */
4122
4123 bool
4124 type_has_user_provided_default_constructor (tree t)
4125 {
4126   tree fns, args;
4127
4128   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4129     return false;
4130
4131   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4132     {
4133       tree fn = OVL_CURRENT (fns);
4134       if (TREE_CODE (fn) == FUNCTION_DECL
4135           && user_provided_p (fn))
4136         {
4137           args = FUNCTION_FIRST_USER_PARMTYPE (fn);
4138           while (args && TREE_PURPOSE (args))
4139             args = TREE_CHAIN (args);
4140           if (!args || args == void_list_node)
4141             return true;
4142         }
4143     }
4144
4145   return false;
4146 }
4147
4148 /* Returns true if FN can be explicitly defaulted.  */
4149
4150 bool
4151 defaultable_fn_p (tree fn)
4152 {
4153   if (DECL_CONSTRUCTOR_P (fn))
4154     {
4155       if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
4156         return true;
4157       else if (copy_fn_p (fn) > 0
4158                && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
4159                    == void_list_node))
4160         return true;
4161       else
4162         return false;
4163     }
4164   else if (DECL_DESTRUCTOR_P (fn))
4165     return true;
4166   else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
4167            && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
4168     return copy_fn_p (fn);
4169   else
4170     return false;
4171 }
4172
4173 /* Remove all zero-width bit-fields from T.  */
4174
4175 static void
4176 remove_zero_width_bit_fields (tree t)
4177 {
4178   tree *fieldsp;
4179
4180   fieldsp = &TYPE_FIELDS (t);
4181   while (*fieldsp)
4182     {
4183       if (TREE_CODE (*fieldsp) == FIELD_DECL
4184           && DECL_C_BIT_FIELD (*fieldsp)
4185           && DECL_INITIAL (*fieldsp))
4186         *fieldsp = TREE_CHAIN (*fieldsp);
4187       else
4188         fieldsp = &TREE_CHAIN (*fieldsp);
4189     }
4190 }
4191
4192 /* Returns TRUE iff we need a cookie when dynamically allocating an
4193    array whose elements have the indicated class TYPE.  */
4194
4195 static bool
4196 type_requires_array_cookie (tree type)
4197 {
4198   tree fns;
4199   bool has_two_argument_delete_p = false;
4200
4201   gcc_assert (CLASS_TYPE_P (type));
4202
4203   /* If there's a non-trivial destructor, we need a cookie.  In order
4204      to iterate through the array calling the destructor for each
4205      element, we'll have to know how many elements there are.  */
4206   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4207     return true;
4208
4209   /* If the usual deallocation function is a two-argument whose second
4210      argument is of type `size_t', then we have to pass the size of
4211      the array to the deallocation function, so we will need to store
4212      a cookie.  */
4213   fns = lookup_fnfields (TYPE_BINFO (type),
4214                          ansi_opname (VEC_DELETE_EXPR),
4215                          /*protect=*/0);
4216   /* If there are no `operator []' members, or the lookup is
4217      ambiguous, then we don't need a cookie.  */
4218   if (!fns || fns == error_mark_node)
4219     return false;
4220   /* Loop through all of the functions.  */
4221   for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4222     {
4223       tree fn;
4224       tree second_parm;
4225
4226       /* Select the current function.  */
4227       fn = OVL_CURRENT (fns);
4228       /* See if this function is a one-argument delete function.  If
4229          it is, then it will be the usual deallocation function.  */
4230       second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4231       if (second_parm == void_list_node)
4232         return false;
4233       /* Do not consider this function if its second argument is an
4234          ellipsis.  */
4235       if (!second_parm)
4236         continue;
4237       /* Otherwise, if we have a two-argument function and the second
4238          argument is `size_t', it will be the usual deallocation
4239          function -- unless there is one-argument function, too.  */
4240       if (TREE_CHAIN (second_parm) == void_list_node
4241           && same_type_p (TREE_VALUE (second_parm), size_type_node))
4242         has_two_argument_delete_p = true;
4243     }
4244
4245   return has_two_argument_delete_p;
4246 }
4247
4248 /* Check the validity of the bases and members declared in T.  Add any
4249    implicitly-generated functions (like copy-constructors and
4250    assignment operators).  Compute various flag bits (like
4251    CLASSTYPE_NON_POD_T) for T.  This routine works purely at the C++
4252    level: i.e., independently of the ABI in use.  */
4253
4254 static void
4255 check_bases_and_members (tree t)
4256 {
4257   /* Nonzero if the implicitly generated copy constructor should take
4258      a non-const reference argument.  */
4259   int cant_have_const_ctor;
4260   /* Nonzero if the implicitly generated assignment operator
4261      should take a non-const reference argument.  */
4262   int no_const_asn_ref;
4263   tree access_decls;
4264   bool saved_complex_asn_ref;
4265   bool saved_nontrivial_dtor;
4266
4267   /* By default, we use const reference arguments and generate default
4268      constructors.  */
4269   cant_have_const_ctor = 0;
4270   no_const_asn_ref = 0;
4271
4272   /* Check all the base-classes.  */
4273   check_bases (t, &cant_have_const_ctor,
4274                &no_const_asn_ref);
4275
4276   /* Check all the method declarations.  */
4277   check_methods (t);
4278
4279   /* Save the initial values of these flags which only indicate whether
4280      or not the class has user-provided functions.  As we analyze the
4281      bases and members we can set these flags for other reasons.  */
4282   saved_complex_asn_ref = TYPE_HAS_COMPLEX_ASSIGN_REF (t);
4283   saved_nontrivial_dtor = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
4284
4285   /* Check all the data member declarations.  We cannot call
4286      check_field_decls until we have called check_bases check_methods,
4287      as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4288      being set appropriately.  */
4289   check_field_decls (t, &access_decls,
4290                      &cant_have_const_ctor,
4291                      &no_const_asn_ref);
4292
4293   /* A nearly-empty class has to be vptr-containing; a nearly empty
4294      class contains just a vptr.  */
4295   if (!TYPE_CONTAINS_VPTR_P (t))
4296     CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4297
4298   /* Do some bookkeeping that will guide the generation of implicitly
4299      declared member functions.  */
4300   TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_CONTAINS_VPTR_P (t);
4301   /* We need to call a constructor for this class if it has a
4302      user-provided constructor, or if the default constructor is going
4303      to initialize the vptr.  (This is not an if-and-only-if;
4304      TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
4305      themselves need constructing.)  */
4306   TYPE_NEEDS_CONSTRUCTING (t)
4307     |= (type_has_user_provided_constructor (t) || TYPE_CONTAINS_VPTR_P (t));
4308   /* [dcl.init.aggr]
4309
4310      An aggregate is an array or a class with no user-provided
4311      constructors ... and no virtual functions.
4312
4313      Again, other conditions for being an aggregate are checked
4314      elsewhere.  */
4315   CLASSTYPE_NON_AGGREGATE (t)
4316     |= (type_has_user_provided_constructor (t) || TYPE_POLYMORPHIC_P (t));
4317   CLASSTYPE_NON_POD_P (t)
4318     |= (CLASSTYPE_NON_AGGREGATE (t)
4319         || saved_nontrivial_dtor || saved_complex_asn_ref);
4320   TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_CONTAINS_VPTR_P (t);
4321   TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_CONTAINS_VPTR_P (t);
4322
4323   /* If the class has no user-declared constructor, but does have
4324      non-static const or reference data members that can never be
4325      initialized, issue a warning.  */
4326   if (warn_uninitialized
4327       /* Classes with user-declared constructors are presumed to
4328          initialize these members.  */
4329       && !TYPE_HAS_USER_CONSTRUCTOR (t)
4330       /* Aggregates can be initialized with brace-enclosed
4331          initializers.  */
4332       && CLASSTYPE_NON_AGGREGATE (t))
4333     {
4334       tree field;
4335
4336       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4337         {
4338           tree type;
4339
4340           if (TREE_CODE (field) != FIELD_DECL)
4341             continue;
4342
4343           type = TREE_TYPE (field);
4344           if (TREE_CODE (type) == REFERENCE_TYPE)
4345             warning (OPT_Wuninitialized, "non-static reference %q+#D "
4346                      "in class without a constructor", field);
4347           else if (CP_TYPE_CONST_P (type)
4348                    && (!CLASS_TYPE_P (type)
4349                        || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4350             warning (OPT_Wuninitialized, "non-static const member %q+#D "
4351                      "in class without a constructor", field);
4352         }
4353     }
4354
4355   /* Synthesize any needed methods.  */
4356   add_implicitly_declared_members (t,
4357                                    cant_have_const_ctor,
4358                                    no_const_asn_ref);
4359
4360   /* Create the in-charge and not-in-charge variants of constructors
4361      and destructors.  */
4362   clone_constructors_and_destructors (t);
4363
4364   /* Process the using-declarations.  */
4365   for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4366     handle_using_decl (TREE_VALUE (access_decls), t);
4367
4368   /* Build and sort the CLASSTYPE_METHOD_VEC.  */
4369   finish_struct_methods (t);
4370
4371   /* Figure out whether or not we will need a cookie when dynamically
4372      allocating an array of this type.  */
4373   TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4374     = type_requires_array_cookie (t);
4375 }
4376
4377 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4378    accordingly.  If a new vfield was created (because T doesn't have a
4379    primary base class), then the newly created field is returned.  It
4380    is not added to the TYPE_FIELDS list; it is the caller's
4381    responsibility to do that.  Accumulate declared virtual functions
4382    on VIRTUALS_P.  */
4383
4384 static tree
4385 create_vtable_ptr (tree t, tree* virtuals_p)
4386 {
4387   tree fn;
4388
4389   /* Collect the virtual functions declared in T.  */
4390   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4391     if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4392         && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4393       {
4394         tree new_virtual = make_node (TREE_LIST);
4395
4396         BV_FN (new_virtual) = fn;
4397         BV_DELTA (new_virtual) = integer_zero_node;
4398         BV_VCALL_INDEX (new_virtual) = NULL_TREE;
4399
4400         TREE_CHAIN (new_virtual) = *virtuals_p;
4401         *virtuals_p = new_virtual;
4402       }
4403
4404   /* If we couldn't find an appropriate base class, create a new field
4405      here.  Even if there weren't any new virtual functions, we might need a
4406      new virtual function table if we're supposed to include vptrs in
4407      all classes that need them.  */
4408   if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4409     {
4410       /* We build this decl with vtbl_ptr_type_node, which is a
4411          `vtable_entry_type*'.  It might seem more precise to use
4412          `vtable_entry_type (*)[N]' where N is the number of virtual
4413          functions.  However, that would require the vtable pointer in
4414          base classes to have a different type than the vtable pointer
4415          in derived classes.  We could make that happen, but that
4416          still wouldn't solve all the problems.  In particular, the
4417          type-based alias analysis code would decide that assignments
4418          to the base class vtable pointer can't alias assignments to
4419          the derived class vtable pointer, since they have different
4420          types.  Thus, in a derived class destructor, where the base
4421          class constructor was inlined, we could generate bad code for
4422          setting up the vtable pointer.
4423
4424          Therefore, we use one type for all vtable pointers.  We still
4425          use a type-correct type; it's just doesn't indicate the array
4426          bounds.  That's better than using `void*' or some such; it's
4427          cleaner, and it let's the alias analysis code know that these
4428          stores cannot alias stores to void*!  */
4429       tree field;
4430
4431       field = build_decl (FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4432       DECL_VIRTUAL_P (field) = 1;
4433       DECL_ARTIFICIAL (field) = 1;
4434       DECL_FIELD_CONTEXT (field) = t;
4435       DECL_FCONTEXT (field) = t;
4436
4437       TYPE_VFIELD (t) = field;
4438
4439       /* This class is non-empty.  */
4440       CLASSTYPE_EMPTY_P (t) = 0;
4441
4442       return field;
4443     }
4444
4445   return NULL_TREE;
4446 }
4447
4448 /* Fixup the inline function given by INFO now that the class is
4449    complete.  */
4450
4451 static void
4452 fixup_pending_inline (tree fn)
4453 {
4454   if (DECL_PENDING_INLINE_INFO (fn))
4455     {
4456       tree args = DECL_ARGUMENTS (fn);
4457       while (args)
4458         {
4459           DECL_CONTEXT (args) = fn;
4460           args = TREE_CHAIN (args);
4461         }
4462     }
4463 }
4464
4465 /* Fixup the inline methods and friends in TYPE now that TYPE is
4466    complete.  */
4467
4468 static void
4469 fixup_inline_methods (tree type)
4470 {
4471   tree method = TYPE_METHODS (type);
4472   VEC(tree,gc) *friends;
4473   unsigned ix;
4474
4475   if (method && TREE_CODE (method) == TREE_VEC)
4476     {
4477       if (TREE_VEC_ELT (method, 1))
4478         method = TREE_VEC_ELT (method, 1);
4479       else if (TREE_VEC_ELT (method, 0))
4480         method = TREE_VEC_ELT (method, 0);
4481       else
4482         method = TREE_VEC_ELT (method, 2);
4483     }
4484
4485   /* Do inline member functions.  */
4486   for (; method; method = TREE_CHAIN (method))
4487     fixup_pending_inline (method);
4488
4489   /* Do friends.  */
4490   for (friends = CLASSTYPE_INLINE_FRIENDS (type), ix = 0;
4491        VEC_iterate (tree, friends, ix, method); ix++)
4492     fixup_pending_inline (method);
4493   CLASSTYPE_INLINE_FRIENDS (type) = NULL;
4494 }
4495
4496 /* Add OFFSET to all base types of BINFO which is a base in the
4497    hierarchy dominated by T.
4498
4499    OFFSET, which is a type offset, is number of bytes.  */
4500
4501 static void
4502 propagate_binfo_offsets (tree binfo, tree offset)
4503 {
4504   int i;
4505   tree primary_binfo;
4506   tree base_binfo;
4507
4508   /* Update BINFO's offset.  */
4509   BINFO_OFFSET (binfo)
4510     = convert (sizetype,
4511                size_binop (PLUS_EXPR,
4512                            convert (ssizetype, BINFO_OFFSET (binfo)),
4513                            offset));
4514
4515   /* Find the primary base class.  */
4516   primary_binfo = get_primary_binfo (binfo);
4517
4518   if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo)
4519     propagate_binfo_offsets (primary_binfo, offset);
4520
4521   /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4522      downwards.  */
4523   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4524     {
4525       /* Don't do the primary base twice.  */
4526       if (base_binfo == primary_binfo)
4527         continue;
4528
4529       if (BINFO_VIRTUAL_P (base_binfo))
4530         continue;
4531
4532       propagate_binfo_offsets (base_binfo, offset);
4533     }
4534 }
4535
4536 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T.  Update
4537    TYPE_ALIGN and TYPE_SIZE for T.  OFFSETS gives the location of
4538    empty subobjects of T.  */
4539
4540 static void
4541 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4542 {
4543   tree vbase;
4544   tree t = rli->t;
4545   bool first_vbase = true;
4546   tree *next_field;
4547
4548   if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0)
4549     return;
4550
4551   if (!abi_version_at_least(2))
4552     {
4553       /* In G++ 3.2, we incorrectly rounded the size before laying out
4554          the virtual bases.  */
4555       finish_record_layout (rli, /*free_p=*/false);
4556 #ifdef STRUCTURE_SIZE_BOUNDARY
4557       /* Packed structures don't need to have minimum size.  */
4558       if (! TYPE_PACKED (t))
4559         TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
4560 #endif
4561       rli->offset = TYPE_SIZE_UNIT (t);
4562       rli->bitpos = bitsize_zero_node;
4563       rli->record_align = TYPE_ALIGN (t);
4564     }
4565
4566   /* Find the last field.  The artificial fields created for virtual
4567      bases will go after the last extant field to date.  */
4568   next_field = &TYPE_FIELDS (t);
4569   while (*next_field)
4570     next_field = &TREE_CHAIN (*next_field);
4571
4572   /* Go through the virtual bases, allocating space for each virtual
4573      base that is not already a primary base class.  These are
4574      allocated in inheritance graph order.  */
4575   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
4576     {
4577       if (!BINFO_VIRTUAL_P (vbase))
4578         continue;
4579
4580       if (!BINFO_PRIMARY_P (vbase))
4581         {
4582           tree basetype = TREE_TYPE (vbase);
4583
4584           /* This virtual base is not a primary base of any class in the
4585              hierarchy, so we have to add space for it.  */
4586           next_field = build_base_field (rli, vbase,
4587                                          offsets, next_field);
4588
4589           /* If the first virtual base might have been placed at a
4590              lower address, had we started from CLASSTYPE_SIZE, rather
4591              than TYPE_SIZE, issue a warning.  There can be both false
4592              positives and false negatives from this warning in rare
4593              cases; to deal with all the possibilities would probably
4594              require performing both layout algorithms and comparing
4595              the results which is not particularly tractable.  */
4596           if (warn_abi
4597               && first_vbase
4598               && (tree_int_cst_lt
4599                   (size_binop (CEIL_DIV_EXPR,
4600                                round_up (CLASSTYPE_SIZE (t),
4601                                          CLASSTYPE_ALIGN (basetype)),
4602                                bitsize_unit_node),
4603                    BINFO_OFFSET (vbase))))
4604             warning (OPT_Wabi,
4605                      "offset of virtual base %qT is not ABI-compliant and "
4606                      "may change in a future version of GCC",
4607                      basetype);
4608
4609           first_vbase = false;
4610         }
4611     }
4612 }
4613
4614 /* Returns the offset of the byte just past the end of the base class
4615    BINFO.  */
4616
4617 static tree
4618 end_of_base (tree binfo)
4619 {
4620   tree size;
4621
4622   if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo)))
4623     size = TYPE_SIZE_UNIT (char_type_node);
4624   else if (is_empty_class (BINFO_TYPE (binfo)))
4625     /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4626        allocate some space for it. It cannot have virtual bases, so
4627        TYPE_SIZE_UNIT is fine.  */
4628     size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4629   else
4630     size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4631
4632   return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
4633 }
4634
4635 /* Returns the offset of the byte just past the end of the base class
4636    with the highest offset in T.  If INCLUDE_VIRTUALS_P is zero, then
4637    only non-virtual bases are included.  */
4638
4639 static tree
4640 end_of_class (tree t, int include_virtuals_p)
4641 {
4642   tree result = size_zero_node;
4643   VEC(tree,gc) *vbases;
4644   tree binfo;
4645   tree base_binfo;
4646   tree offset;
4647   int i;
4648
4649   for (binfo = TYPE_BINFO (t), i = 0;
4650        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4651     {
4652       if (!include_virtuals_p
4653           && BINFO_VIRTUAL_P (base_binfo)
4654           && (!BINFO_PRIMARY_P (base_binfo)
4655               || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t)))
4656         continue;
4657
4658       offset = end_of_base (base_binfo);
4659       if (INT_CST_LT_UNSIGNED (result, offset))
4660         result = offset;
4661     }
4662
4663   /* G++ 3.2 did not check indirect virtual bases.  */
4664   if (abi_version_at_least (2) && include_virtuals_p)
4665     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4666          VEC_iterate (tree, vbases, i, base_binfo); i++)
4667       {
4668         offset = end_of_base (base_binfo);
4669         if (INT_CST_LT_UNSIGNED (result, offset))
4670           result = offset;
4671       }
4672
4673   return result;
4674 }
4675
4676 /* Warn about bases of T that are inaccessible because they are
4677    ambiguous.  For example:
4678
4679      struct S {};
4680      struct T : public S {};
4681      struct U : public S, public T {};
4682
4683    Here, `(S*) new U' is not allowed because there are two `S'
4684    subobjects of U.  */
4685
4686 static void
4687 warn_about_ambiguous_bases (tree t)
4688 {
4689   int i;
4690   VEC(tree,gc) *vbases;
4691   tree basetype;
4692   tree binfo;
4693   tree base_binfo;
4694
4695   /* If there are no repeated bases, nothing can be ambiguous.  */
4696   if (!CLASSTYPE_REPEATED_BASE_P (t))
4697     return;
4698
4699   /* Check direct bases.  */
4700   for (binfo = TYPE_BINFO (t), i = 0;
4701        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4702     {
4703       basetype = BINFO_TYPE (base_binfo);
4704
4705       if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
4706         warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
4707                  basetype, t);
4708     }
4709
4710   /* Check for ambiguous virtual bases.  */
4711   if (extra_warnings)
4712     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4713          VEC_iterate (tree, vbases, i, binfo); i++)
4714       {
4715         basetype = BINFO_TYPE (binfo);
4716
4717         if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
4718           warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due to ambiguity",
4719                    basetype, t);
4720       }
4721 }
4722
4723 /* Compare two INTEGER_CSTs K1 and K2.  */
4724
4725 static int
4726 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
4727 {
4728   return tree_int_cst_compare ((tree) k1, (tree) k2);
4729 }
4730
4731 /* Increase the size indicated in RLI to account for empty classes
4732    that are "off the end" of the class.  */
4733
4734 static void
4735 include_empty_classes (record_layout_info rli)
4736 {
4737   tree eoc;
4738   tree rli_size;
4739
4740   /* It might be the case that we grew the class to allocate a
4741      zero-sized base class.  That won't be reflected in RLI, yet,
4742      because we are willing to overlay multiple bases at the same
4743      offset.  However, now we need to make sure that RLI is big enough
4744      to reflect the entire class.  */
4745   eoc = end_of_class (rli->t,
4746                       CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
4747   rli_size = rli_size_unit_so_far (rli);
4748   if (TREE_CODE (rli_size) == INTEGER_CST
4749       && INT_CST_LT_UNSIGNED (rli_size, eoc))
4750     {
4751       if (!abi_version_at_least (2))
4752         /* In version 1 of the ABI, the size of a class that ends with
4753            a bitfield was not rounded up to a whole multiple of a
4754            byte.  Because rli_size_unit_so_far returns only the number
4755            of fully allocated bytes, any extra bits were not included
4756            in the size.  */
4757         rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
4758       else
4759         /* The size should have been rounded to a whole byte.  */
4760         gcc_assert (tree_int_cst_equal
4761                     (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT)));
4762       rli->bitpos
4763         = size_binop (PLUS_EXPR,
4764                       rli->bitpos,
4765                       size_binop (MULT_EXPR,
4766                                   convert (bitsizetype,
4767                                            size_binop (MINUS_EXPR,
4768                                                        eoc, rli_size)),
4769                                   bitsize_int (BITS_PER_UNIT)));
4770       normalize_rli (rli);
4771     }
4772 }
4773
4774 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T.  Calculate
4775    BINFO_OFFSETs for all of the base-classes.  Position the vtable
4776    pointer.  Accumulate declared virtual functions on VIRTUALS_P.  */
4777
4778 static void
4779 layout_class_type (tree t, tree *virtuals_p)
4780 {
4781   tree non_static_data_members;
4782   tree field;
4783   tree vptr;
4784   record_layout_info rli;
4785   /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4786      types that appear at that offset.  */
4787   splay_tree empty_base_offsets;
4788   /* True if the last field layed out was a bit-field.  */
4789   bool last_field_was_bitfield = false;
4790   /* The location at which the next field should be inserted.  */
4791   tree *next_field;
4792   /* T, as a base class.  */
4793   tree base_t;
4794
4795   /* Keep track of the first non-static data member.  */
4796   non_static_data_members = TYPE_FIELDS (t);
4797
4798   /* Start laying out the record.  */
4799   rli = start_record_layout (t);
4800
4801   /* Mark all the primary bases in the hierarchy.  */
4802   determine_primary_bases (t);
4803
4804   /* Create a pointer to our virtual function table.  */
4805   vptr = create_vtable_ptr (t, virtuals_p);
4806
4807   /* The vptr is always the first thing in the class.  */
4808   if (vptr)
4809     {
4810       TREE_CHAIN (vptr) = TYPE_FIELDS (t);
4811       TYPE_FIELDS (t) = vptr;
4812       next_field = &TREE_CHAIN (vptr);
4813       place_field (rli, vptr);
4814     }
4815   else
4816     next_field = &TYPE_FIELDS (t);
4817
4818   /* Build FIELD_DECLs for all of the non-virtual base-types.  */
4819   empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
4820                                        NULL, NULL);
4821   build_base_fields (rli, empty_base_offsets, next_field);
4822
4823   /* Layout the non-static data members.  */
4824   for (field = non_static_data_members; field; field = TREE_CHAIN (field))
4825     {
4826       tree type;
4827       tree padding;
4828
4829       /* We still pass things that aren't non-static data members to
4830          the back end, in case it wants to do something with them.  */
4831       if (TREE_CODE (field) != FIELD_DECL)
4832         {
4833           place_field (rli, field);
4834           /* If the static data member has incomplete type, keep track
4835              of it so that it can be completed later.  (The handling
4836              of pending statics in finish_record_layout is
4837              insufficient; consider:
4838
4839                struct S1;
4840                struct S2 { static S1 s1; };
4841
4842              At this point, finish_record_layout will be called, but
4843              S1 is still incomplete.)  */
4844           if (TREE_CODE (field) == VAR_DECL)
4845             {
4846               maybe_register_incomplete_var (field);
4847               /* The visibility of static data members is determined
4848                  at their point of declaration, not their point of
4849                  definition.  */
4850               determine_visibility (field);
4851             }
4852           continue;
4853         }
4854
4855       type = TREE_TYPE (field);
4856       if (type == error_mark_node)
4857         continue;
4858
4859       padding = NULL_TREE;
4860
4861       /* If this field is a bit-field whose width is greater than its
4862          type, then there are some special rules for allocating
4863          it.  */
4864       if (DECL_C_BIT_FIELD (field)
4865           && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
4866         {
4867           unsigned int itk;
4868           tree integer_type;
4869           bool was_unnamed_p = false;
4870           /* We must allocate the bits as if suitably aligned for the
4871              longest integer type that fits in this many bits.  type
4872              of the field.  Then, we are supposed to use the left over
4873              bits as additional padding.  */
4874           for (itk = itk_char; itk != itk_none; ++itk)
4875             if (INT_CST_LT (DECL_SIZE (field),
4876                             TYPE_SIZE (integer_types[itk])))
4877               break;
4878
4879           /* ITK now indicates a type that is too large for the
4880              field.  We have to back up by one to find the largest
4881              type that fits.  */
4882           integer_type = integer_types[itk - 1];
4883
4884           /* Figure out how much additional padding is required.  GCC
4885              3.2 always created a padding field, even if it had zero
4886              width.  */
4887           if (!abi_version_at_least (2)
4888               || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
4889             {
4890               if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
4891                 /* In a union, the padding field must have the full width
4892                    of the bit-field; all fields start at offset zero.  */
4893                 padding = DECL_SIZE (field);
4894               else
4895                 {
4896                   if (TREE_CODE (t) == UNION_TYPE)
4897                     warning (OPT_Wabi, "size assigned to %qT may not be "
4898                              "ABI-compliant and may change in a future "
4899                              "version of GCC",
4900                              t);
4901                   padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
4902                                         TYPE_SIZE (integer_type));
4903                 }
4904             }
4905 #ifdef PCC_BITFIELD_TYPE_MATTERS
4906           /* An unnamed bitfield does not normally affect the
4907              alignment of the containing class on a target where
4908              PCC_BITFIELD_TYPE_MATTERS.  But, the C++ ABI does not
4909              make any exceptions for unnamed bitfields when the
4910              bitfields are longer than their types.  Therefore, we
4911              temporarily give the field a name.  */
4912           if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
4913             {
4914               was_unnamed_p = true;
4915               DECL_NAME (field) = make_anon_name ();
4916             }
4917 #endif
4918           DECL_SIZE (field) = TYPE_SIZE (integer_type);
4919           DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
4920           DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
4921           layout_nonempty_base_or_field (rli, field, NULL_TREE,
4922                                          empty_base_offsets);
4923           if (was_unnamed_p)
4924             DECL_NAME (field) = NULL_TREE;
4925           /* Now that layout has been performed, set the size of the
4926              field to the size of its declared type; the rest of the
4927              field is effectively invisible.  */
4928           DECL_SIZE (field) = TYPE_SIZE (type);
4929           /* We must also reset the DECL_MODE of the field.  */
4930           if (abi_version_at_least (2))
4931             DECL_MODE (field) = TYPE_MODE (type);
4932           else if (warn_abi
4933                    && DECL_MODE (field) != TYPE_MODE (type))
4934             /* Versions of G++ before G++ 3.4 did not reset the
4935                DECL_MODE.  */
4936             warning (OPT_Wabi,
4937                      "the offset of %qD may not be ABI-compliant and may "
4938                      "change in a future version of GCC", field);
4939         }
4940       else
4941         layout_nonempty_base_or_field (rli, field, NULL_TREE,
4942                                        empty_base_offsets);
4943
4944       /* Remember the location of any empty classes in FIELD.  */
4945       if (abi_version_at_least (2))
4946         record_subobject_offsets (TREE_TYPE (field),
4947                                   byte_position(field),
4948                                   empty_base_offsets,
4949                                   /*is_data_member=*/true);
4950
4951       /* If a bit-field does not immediately follow another bit-field,
4952          and yet it starts in the middle of a byte, we have failed to
4953          comply with the ABI.  */
4954       if (warn_abi
4955           && DECL_C_BIT_FIELD (field)
4956           /* The TREE_NO_WARNING flag gets set by Objective-C when
4957              laying out an Objective-C class.  The ObjC ABI differs
4958              from the C++ ABI, and so we do not want a warning
4959              here.  */
4960           && !TREE_NO_WARNING (field)
4961           && !last_field_was_bitfield
4962           && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
4963                                          DECL_FIELD_BIT_OFFSET (field),
4964                                          bitsize_unit_node)))
4965         warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may "
4966                  "change in a future version of GCC", field);
4967
4968       /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4969          offset of the field.  */
4970       if (warn_abi
4971           && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
4972                                   byte_position (field))
4973           && contains_empty_class_p (TREE_TYPE (field)))
4974         warning (OPT_Wabi, "%q+D contains empty classes which may cause base "
4975                  "classes to be placed at different locations in a "
4976                  "future version of GCC", field);
4977
4978       /* The middle end uses the type of expressions to determine the
4979          possible range of expression values.  In order to optimize
4980          "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
4981          must be made aware of the width of "i", via its type.
4982
4983          Because C++ does not have integer types of arbitrary width,
4984          we must (for the purposes of the front end) convert from the
4985          type assigned here to the declared type of the bitfield
4986          whenever a bitfield expression is used as an rvalue.
4987          Similarly, when assigning a value to a bitfield, the value
4988          must be converted to the type given the bitfield here.  */
4989       if (DECL_C_BIT_FIELD (field))
4990         {
4991           unsigned HOST_WIDE_INT width;
4992           tree ftype = TREE_TYPE (field);
4993           width = tree_low_cst (DECL_SIZE (field), /*unsignedp=*/1);
4994           if (width != TYPE_PRECISION (ftype))
4995             {
4996               TREE_TYPE (field)
4997                 = c_build_bitfield_integer_type (width,
4998                                                  TYPE_UNSIGNED (ftype));
4999               TREE_TYPE (field)
5000                 = cp_build_qualified_type (TREE_TYPE (field),
5001                                            TYPE_QUALS (ftype));
5002             }
5003         }
5004
5005       /* If we needed additional padding after this field, add it
5006          now.  */
5007       if (padding)
5008         {
5009           tree padding_field;
5010
5011           padding_field = build_decl (FIELD_DECL,
5012                                       NULL_TREE,
5013                                       char_type_node);
5014           DECL_BIT_FIELD (padding_field) = 1;
5015           DECL_SIZE (padding_field) = padding;
5016           DECL_CONTEXT (padding_field) = t;
5017           DECL_ARTIFICIAL (padding_field) = 1;
5018           DECL_IGNORED_P (padding_field) = 1;
5019           layout_nonempty_base_or_field (rli, padding_field,
5020                                          NULL_TREE,
5021                                          empty_base_offsets);
5022         }
5023
5024       last_field_was_bitfield = DECL_C_BIT_FIELD (field);
5025     }
5026
5027   if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
5028     {
5029       /* Make sure that we are on a byte boundary so that the size of
5030          the class without virtual bases will always be a round number
5031          of bytes.  */
5032       rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT);
5033       normalize_rli (rli);
5034     }
5035
5036   /* G++ 3.2 does not allow virtual bases to be overlaid with tail
5037      padding.  */
5038   if (!abi_version_at_least (2))
5039     include_empty_classes(rli);
5040
5041   /* Delete all zero-width bit-fields from the list of fields.  Now
5042      that the type is laid out they are no longer important.  */
5043   remove_zero_width_bit_fields (t);
5044
5045   /* Create the version of T used for virtual bases.  We do not use
5046      make_class_type for this version; this is an artificial type.  For
5047      a POD type, we just reuse T.  */
5048   if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t))
5049     {
5050       base_t = make_node (TREE_CODE (t));
5051
5052       /* Set the size and alignment for the new type.  In G++ 3.2, all
5053          empty classes were considered to have size zero when used as
5054          base classes.  */
5055       if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
5056         {
5057           TYPE_SIZE (base_t) = bitsize_zero_node;
5058           TYPE_SIZE_UNIT (base_t) = size_zero_node;
5059           if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
5060             warning (OPT_Wabi,
5061                      "layout of classes derived from empty class %qT "
5062                      "may change in a future version of GCC",
5063                      t);
5064         }
5065       else
5066         {
5067           tree eoc;
5068
5069           /* If the ABI version is not at least two, and the last
5070              field was a bit-field, RLI may not be on a byte
5071              boundary.  In particular, rli_size_unit_so_far might
5072              indicate the last complete byte, while rli_size_so_far
5073              indicates the total number of bits used.  Therefore,
5074              rli_size_so_far, rather than rli_size_unit_so_far, is
5075              used to compute TYPE_SIZE_UNIT.  */
5076           eoc = end_of_class (t, /*include_virtuals_p=*/0);
5077           TYPE_SIZE_UNIT (base_t)
5078             = size_binop (MAX_EXPR,
5079                           convert (sizetype,
5080                                    size_binop (CEIL_DIV_EXPR,
5081                                                rli_size_so_far (rli),
5082                                                bitsize_int (BITS_PER_UNIT))),
5083                           eoc);
5084           TYPE_SIZE (base_t)
5085             = size_binop (MAX_EXPR,
5086                           rli_size_so_far (rli),
5087                           size_binop (MULT_EXPR,
5088                                       convert (bitsizetype, eoc),
5089                                       bitsize_int (BITS_PER_UNIT)));
5090         }
5091       TYPE_ALIGN (base_t) = rli->record_align;
5092       TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
5093
5094       /* Copy the fields from T.  */
5095       next_field = &TYPE_FIELDS (base_t);
5096       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
5097         if (TREE_CODE (field) == FIELD_DECL)
5098           {
5099             *next_field = build_decl (FIELD_DECL,
5100                                       DECL_NAME (field),
5101                                       TREE_TYPE (field));
5102             DECL_CONTEXT (*next_field) = base_t;
5103             DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
5104             DECL_FIELD_BIT_OFFSET (*next_field)
5105               = DECL_FIELD_BIT_OFFSET (field);
5106             DECL_SIZE (*next_field) = DECL_SIZE (field);
5107             DECL_MODE (*next_field) = DECL_MODE (field);
5108             next_field = &TREE_CHAIN (*next_field);
5109           }
5110
5111       /* Record the base version of the type.  */
5112       CLASSTYPE_AS_BASE (t) = base_t;
5113       TYPE_CONTEXT (base_t) = t;
5114     }
5115   else
5116     CLASSTYPE_AS_BASE (t) = t;
5117
5118   /* Every empty class contains an empty class.  */
5119   if (CLASSTYPE_EMPTY_P (t))
5120     CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
5121
5122   /* Set the TYPE_DECL for this type to contain the right
5123      value for DECL_OFFSET, so that we can use it as part
5124      of a COMPONENT_REF for multiple inheritance.  */
5125   layout_decl (TYPE_MAIN_DECL (t), 0);
5126
5127   /* Now fix up any virtual base class types that we left lying
5128      around.  We must get these done before we try to lay out the
5129      virtual function table.  As a side-effect, this will remove the
5130      base subobject fields.  */
5131   layout_virtual_bases (rli, empty_base_offsets);
5132
5133   /* Make sure that empty classes are reflected in RLI at this
5134      point.  */
5135   include_empty_classes(rli);
5136
5137   /* Make sure not to create any structures with zero size.  */
5138   if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
5139     place_field (rli,
5140                  build_decl (FIELD_DECL, NULL_TREE, char_type_node));
5141
5142   /* Let the back end lay out the type.  */
5143   finish_record_layout (rli, /*free_p=*/true);
5144
5145   /* Warn about bases that can't be talked about due to ambiguity.  */
5146   warn_about_ambiguous_bases (t);
5147
5148   /* Now that we're done with layout, give the base fields the real types.  */
5149   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
5150     if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
5151       TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
5152
5153   /* Clean up.  */
5154   splay_tree_delete (empty_base_offsets);
5155
5156   if (CLASSTYPE_EMPTY_P (t)
5157       && tree_int_cst_lt (sizeof_biggest_empty_class,
5158                           TYPE_SIZE_UNIT (t)))
5159     sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
5160 }
5161
5162 /* Determine the "key method" for the class type indicated by TYPE,
5163    and set CLASSTYPE_KEY_METHOD accordingly.  */
5164
5165 void
5166 determine_key_method (tree type)
5167 {
5168   tree method;
5169
5170   if (TYPE_FOR_JAVA (type)
5171       || processing_template_decl
5172       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
5173       || CLASSTYPE_INTERFACE_KNOWN (type))
5174     return;
5175
5176   /* The key method is the first non-pure virtual function that is not
5177      inline at the point of class definition.  On some targets the
5178      key function may not be inline; those targets should not call
5179      this function until the end of the translation unit.  */
5180   for (method = TYPE_METHODS (type); method != NULL_TREE;
5181        method = TREE_CHAIN (method))
5182     if (DECL_VINDEX (method) != NULL_TREE
5183         && ! DECL_DECLARED_INLINE_P (method)
5184         && ! DECL_PURE_VIRTUAL_P (method))
5185       {
5186         CLASSTYPE_KEY_METHOD (type) = method;
5187         break;
5188       }
5189
5190   return;
5191 }
5192
5193 /* Perform processing required when the definition of T (a class type)
5194    is complete.  */
5195
5196 void
5197 finish_struct_1 (tree t)
5198 {
5199   tree x;
5200   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
5201   tree virtuals = NULL_TREE;
5202   int n_fields = 0;
5203
5204   if (COMPLETE_TYPE_P (t))
5205     {
5206       gcc_assert (MAYBE_CLASS_TYPE_P (t));
5207       error ("redefinition of %q#T", t);
5208       popclass ();
5209       return;
5210     }
5211
5212   /* If this type was previously laid out as a forward reference,
5213      make sure we lay it out again.  */
5214   TYPE_SIZE (t) = NULL_TREE;
5215   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5216
5217   fixup_inline_methods (t);
5218
5219   /* Make assumptions about the class; we'll reset the flags if
5220      necessary.  */
5221   CLASSTYPE_EMPTY_P (t) = 1;
5222   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5223   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5224
5225   /* Do end-of-class semantic processing: checking the validity of the
5226      bases and members and add implicitly generated methods.  */
5227   check_bases_and_members (t);
5228
5229   /* Find the key method.  */
5230   if (TYPE_CONTAINS_VPTR_P (t))
5231     {
5232       /* The Itanium C++ ABI permits the key method to be chosen when
5233          the class is defined -- even though the key method so
5234          selected may later turn out to be an inline function.  On
5235          some systems (such as ARM Symbian OS) the key method cannot
5236          be determined until the end of the translation unit.  On such
5237          systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
5238          will cause the class to be added to KEYED_CLASSES.  Then, in
5239          finish_file we will determine the key method.  */
5240       if (targetm.cxx.key_method_may_be_inline ())
5241         determine_key_method (t);
5242
5243       /* If a polymorphic class has no key method, we may emit the vtable
5244          in every translation unit where the class definition appears.  */
5245       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5246         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5247     }
5248
5249   /* Layout the class itself.  */
5250   layout_class_type (t, &virtuals);
5251   if (CLASSTYPE_AS_BASE (t) != t)
5252     /* We use the base type for trivial assignments, and hence it
5253        needs a mode.  */
5254     compute_record_mode (CLASSTYPE_AS_BASE (t));
5255
5256   virtuals = modify_all_vtables (t, nreverse (virtuals));
5257
5258   /* If necessary, create the primary vtable for this class.  */
5259   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5260     {
5261       /* We must enter these virtuals into the table.  */
5262       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5263         build_primary_vtable (NULL_TREE, t);
5264       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5265         /* Here we know enough to change the type of our virtual
5266            function table, but we will wait until later this function.  */
5267         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5268     }
5269
5270   if (TYPE_CONTAINS_VPTR_P (t))
5271     {
5272       int vindex;
5273       tree fn;
5274
5275       if (BINFO_VTABLE (TYPE_BINFO (t)))
5276         gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
5277       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5278         gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
5279
5280       /* Add entries for virtual functions introduced by this class.  */
5281       BINFO_VIRTUALS (TYPE_BINFO (t))
5282         = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
5283
5284       /* Set DECL_VINDEX for all functions declared in this class.  */
5285       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5286            fn;
5287            fn = TREE_CHAIN (fn),
5288              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5289                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5290         {
5291           tree fndecl = BV_FN (fn);
5292
5293           if (DECL_THUNK_P (fndecl))
5294             /* A thunk. We should never be calling this entry directly
5295                from this vtable -- we'd use the entry for the non
5296                thunk base function.  */
5297             DECL_VINDEX (fndecl) = NULL_TREE;
5298           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5299             DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
5300         }
5301     }
5302
5303   finish_struct_bits (t);
5304
5305   /* Complete the rtl for any static member objects of the type we're
5306      working on.  */
5307   for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5308     if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5309         && TREE_TYPE (x) != error_mark_node
5310         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5311       DECL_MODE (x) = TYPE_MODE (t);
5312
5313   /* Done with FIELDS...now decide whether to sort these for
5314      faster lookups later.
5315
5316      We use a small number because most searches fail (succeeding
5317      ultimately as the search bores through the inheritance
5318      hierarchy), and we want this failure to occur quickly.  */
5319
5320   n_fields = count_fields (TYPE_FIELDS (t));
5321   if (n_fields > 7)
5322     {
5323       struct sorted_fields_type *field_vec = GGC_NEWVAR
5324          (struct sorted_fields_type,
5325           sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
5326       field_vec->len = n_fields;
5327       add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5328       qsort (field_vec->elts, n_fields, sizeof (tree),
5329              field_decl_cmp);
5330       if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5331         retrofit_lang_decl (TYPE_MAIN_DECL (t));
5332       DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5333     }
5334
5335   /* Complain if one of the field types requires lower visibility.  */
5336   constrain_class_visibility (t);
5337
5338   /* Make the rtl for any new vtables we have created, and unmark
5339      the base types we marked.  */
5340   finish_vtbls (t);
5341
5342   /* Build the VTT for T.  */
5343   build_vtt (t);
5344
5345   /* This warning does not make sense for Java classes, since they
5346      cannot have destructors.  */
5347   if (!TYPE_FOR_JAVA (t) && warn_nonvdtor && TYPE_POLYMORPHIC_P (t))
5348     {
5349       tree dtor;
5350
5351       dtor = CLASSTYPE_DESTRUCTORS (t);
5352       if (/* An implicitly declared destructor is always public.  And,
5353              if it were virtual, we would have created it by now.  */
5354           !dtor
5355           || (!DECL_VINDEX (dtor)
5356               && (/* public non-virtual */
5357                   (!TREE_PRIVATE (dtor) && !TREE_PROTECTED (dtor))
5358                    || (/* non-public non-virtual with friends */
5359                        (TREE_PRIVATE (dtor) || TREE_PROTECTED (dtor))
5360                         && (CLASSTYPE_FRIEND_CLASSES (t)
5361                         || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))))))
5362         warning (OPT_Wnon_virtual_dtor,
5363                  "%q#T has virtual functions and accessible"
5364                  " non-virtual destructor", t);
5365     }
5366
5367   complete_vars (t);
5368
5369   if (warn_overloaded_virtual)
5370     warn_hidden (t);
5371
5372   /* Class layout, assignment of virtual table slots, etc., is now
5373      complete.  Give the back end a chance to tweak the visibility of
5374      the class or perform any other required target modifications.  */
5375   targetm.cxx.adjust_class_at_definition (t);
5376
5377   maybe_suppress_debug_info (t);
5378
5379   dump_class_hierarchy (t);
5380
5381   /* Finish debugging output for this type.  */
5382   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5383 }
5384
5385 /* When T was built up, the member declarations were added in reverse
5386    order.  Rearrange them to declaration order.  */
5387
5388 void
5389 unreverse_member_declarations (tree t)
5390 {
5391   tree next;
5392   tree prev;
5393   tree x;
5394
5395   /* The following lists are all in reverse order.  Put them in
5396      declaration order now.  */
5397   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5398   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5399
5400   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5401      reverse order, so we can't just use nreverse.  */
5402   prev = NULL_TREE;
5403   for (x = TYPE_FIELDS (t);
5404        x && TREE_CODE (x) != TYPE_DECL;
5405        x = next)
5406     {
5407       next = TREE_CHAIN (x);
5408       TREE_CHAIN (x) = prev;
5409       prev = x;
5410     }
5411   if (prev)
5412     {
5413       TREE_CHAIN (TYPE_FIELDS (t)) = x;
5414       if (prev)
5415         TYPE_FIELDS (t) = prev;
5416     }
5417 }
5418
5419 tree
5420 finish_struct (tree t, tree attributes)
5421 {
5422   location_t saved_loc = input_location;
5423
5424   /* Now that we've got all the field declarations, reverse everything
5425      as necessary.  */
5426   unreverse_member_declarations (t);
5427
5428   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5429
5430   /* Nadger the current location so that diagnostics point to the start of
5431      the struct, not the end.  */
5432   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5433
5434   if (processing_template_decl)
5435     {
5436       tree x;
5437
5438       finish_struct_methods (t);
5439       TYPE_SIZE (t) = bitsize_zero_node;
5440       TYPE_SIZE_UNIT (t) = size_zero_node;
5441
5442       /* We need to emit an error message if this type was used as a parameter
5443          and it is an abstract type, even if it is a template. We construct
5444          a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5445          account and we call complete_vars with this type, which will check
5446          the PARM_DECLS. Note that while the type is being defined,
5447          CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5448          (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it.  */
5449       CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5450       for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
5451         if (DECL_PURE_VIRTUAL_P (x))
5452           VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
5453       complete_vars (t);
5454     }
5455   else
5456     finish_struct_1 (t);
5457
5458   input_location = saved_loc;
5459
5460   TYPE_BEING_DEFINED (t) = 0;
5461
5462   if (current_class_type)
5463     popclass ();
5464   else
5465     error ("trying to finish struct, but kicked out due to previous parse errors");
5466
5467   if (processing_template_decl && at_function_scope_p ())
5468     add_stmt (build_min (TAG_DEFN, t));
5469
5470   return t;
5471 }
5472 \f
5473 /* Return the dynamic type of INSTANCE, if known.
5474    Used to determine whether the virtual function table is needed
5475    or not.
5476
5477    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5478    of our knowledge of its type.  *NONNULL should be initialized
5479    before this function is called.  */
5480
5481 static tree
5482 fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
5483 {
5484 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
5485
5486   switch (TREE_CODE (instance))
5487     {
5488     case INDIRECT_REF:
5489       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5490         return NULL_TREE;
5491       else
5492         return RECUR (TREE_OPERAND (instance, 0));
5493
5494     case CALL_EXPR:
5495       /* This is a call to a constructor, hence it's never zero.  */
5496       if (TREE_HAS_CONSTRUCTOR (instance))
5497         {
5498           if (nonnull)
5499             *nonnull = 1;
5500           return TREE_TYPE (instance);
5501         }
5502       return NULL_TREE;
5503
5504     case SAVE_EXPR:
5505       /* This is a call to a constructor, hence it's never zero.  */
5506       if (TREE_HAS_CONSTRUCTOR (instance))
5507         {
5508           if (nonnull)
5509             *nonnull = 1;
5510           return TREE_TYPE (instance);
5511         }
5512       return RECUR (TREE_OPERAND (instance, 0));
5513
5514     case POINTER_PLUS_EXPR:
5515     case PLUS_EXPR:
5516     case MINUS_EXPR:
5517       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5518         return RECUR (TREE_OPERAND (instance, 0));
5519       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5520         /* Propagate nonnull.  */
5521         return RECUR (TREE_OPERAND (instance, 0));
5522
5523       return NULL_TREE;
5524
5525     CASE_CONVERT:
5526       return RECUR (TREE_OPERAND (instance, 0));
5527
5528     case ADDR_EXPR:
5529       instance = TREE_OPERAND (instance, 0);
5530       if (nonnull)
5531         {
5532           /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5533              with a real object -- given &p->f, p can still be null.  */
5534           tree t = get_base_address (instance);
5535           /* ??? Probably should check DECL_WEAK here.  */
5536           if (t && DECL_P (t))
5537             *nonnull = 1;
5538         }
5539       return RECUR (instance);
5540
5541     case COMPONENT_REF:
5542       /* If this component is really a base class reference, then the field
5543          itself isn't definitive.  */
5544       if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5545         return RECUR (TREE_OPERAND (instance, 0));
5546       return RECUR (TREE_OPERAND (instance, 1));
5547
5548     case VAR_DECL:
5549     case FIELD_DECL:
5550       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5551           && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance))))
5552         {
5553           if (nonnull)
5554             *nonnull = 1;
5555           return TREE_TYPE (TREE_TYPE (instance));
5556         }
5557       /* fall through...  */
5558     case TARGET_EXPR:
5559     case PARM_DECL:
5560     case RESULT_DECL:
5561       if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance)))
5562         {
5563           if (nonnull)
5564             *nonnull = 1;
5565           return TREE_TYPE (instance);
5566         }
5567       else if (instance == current_class_ptr)
5568         {
5569           if (nonnull)
5570             *nonnull = 1;
5571
5572           /* if we're in a ctor or dtor, we know our type.  */
5573           if (DECL_LANG_SPECIFIC (current_function_decl)
5574               && (DECL_CONSTRUCTOR_P (current_function_decl)
5575                   || DECL_DESTRUCTOR_P (current_function_decl)))
5576             {
5577               if (cdtorp)
5578                 *cdtorp = 1;
5579               return TREE_TYPE (TREE_TYPE (instance));
5580             }
5581         }
5582       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5583         {
5584           /* We only need one hash table because it is always left empty.  */
5585           static htab_t ht;
5586           if (!ht)
5587             ht = htab_create (37,
5588                               htab_hash_pointer,
5589                               htab_eq_pointer,
5590                               /*htab_del=*/NULL);
5591
5592           /* Reference variables should be references to objects.  */
5593           if (nonnull)
5594             *nonnull = 1;
5595
5596           /* Enter the INSTANCE in a table to prevent recursion; a
5597              variable's initializer may refer to the variable
5598              itself.  */
5599           if (TREE_CODE (instance) == VAR_DECL
5600               && DECL_INITIAL (instance)
5601               && !htab_find (ht, instance))
5602             {
5603               tree type;
5604               void **slot;
5605
5606               slot = htab_find_slot (ht, instance, INSERT);
5607               *slot = instance;
5608               type = RECUR (DECL_INITIAL (instance));
5609               htab_remove_elt (ht, instance);
5610
5611               return type;
5612             }
5613         }
5614       return NULL_TREE;
5615
5616     default:
5617       return NULL_TREE;
5618     }
5619 #undef RECUR
5620 }
5621
5622 /* Return nonzero if the dynamic type of INSTANCE is known, and
5623    equivalent to the static type.  We also handle the case where
5624    INSTANCE is really a pointer. Return negative if this is a
5625    ctor/dtor. There the dynamic type is known, but this might not be
5626    the most derived base of the original object, and hence virtual
5627    bases may not be layed out according to this type.
5628
5629    Used to determine whether the virtual function table is needed
5630    or not.
5631
5632    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5633    of our knowledge of its type.  *NONNULL should be initialized
5634    before this function is called.  */
5635
5636 int
5637 resolves_to_fixed_type_p (tree instance, int* nonnull)
5638 {
5639   tree t = TREE_TYPE (instance);
5640   int cdtorp = 0;
5641   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5642   if (fixed == NULL_TREE)
5643     return 0;
5644   if (POINTER_TYPE_P (t))
5645     t = TREE_TYPE (t);
5646   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5647     return 0;
5648   return cdtorp ? -1 : 1;
5649 }
5650
5651 \f
5652 void
5653 init_class_processing (void)
5654 {
5655   current_class_depth = 0;
5656   current_class_stack_size = 10;
5657   current_class_stack
5658     = XNEWVEC (struct class_stack_node, current_class_stack_size);
5659   local_classes = VEC_alloc (tree, gc, 8);
5660   sizeof_biggest_empty_class = size_zero_node;
5661
5662   ridpointers[(int) RID_PUBLIC] = access_public_node;
5663   ridpointers[(int) RID_PRIVATE] = access_private_node;
5664   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5665 }
5666
5667 /* Restore the cached PREVIOUS_CLASS_LEVEL.  */
5668
5669 static void
5670 restore_class_cache (void)
5671 {
5672   tree type;
5673
5674   /* We are re-entering the same class we just left, so we don't
5675      have to search the whole inheritance matrix to find all the
5676      decls to bind again.  Instead, we install the cached
5677      class_shadowed list and walk through it binding names.  */
5678   push_binding_level (previous_class_level);
5679   class_binding_level = previous_class_level;
5680   /* Restore IDENTIFIER_TYPE_VALUE.  */
5681   for (type = class_binding_level->type_shadowed;
5682        type;
5683        type = TREE_CHAIN (type))
5684     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5685 }
5686
5687 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5688    appropriate for TYPE.
5689
5690    So that we may avoid calls to lookup_name, we cache the _TYPE
5691    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5692
5693    For multiple inheritance, we perform a two-pass depth-first search
5694    of the type lattice.  */
5695
5696 void
5697 pushclass (tree type)
5698 {
5699   class_stack_node_t csn;
5700
5701   type = TYPE_MAIN_VARIANT (type);
5702
5703   /* Make sure there is enough room for the new entry on the stack.  */
5704   if (current_class_depth + 1 >= current_class_stack_size)
5705     {
5706       current_class_stack_size *= 2;
5707       current_class_stack
5708         = XRESIZEVEC (struct class_stack_node, current_class_stack,
5709                       current_class_stack_size);
5710     }
5711
5712   /* Insert a new entry on the class stack.  */
5713   csn = current_class_stack + current_class_depth;
5714   csn->name = current_class_name;
5715   csn->type = current_class_type;
5716   csn->access = current_access_specifier;
5717   csn->names_used = 0;
5718   csn->hidden = 0;
5719   current_class_depth++;
5720
5721   /* Now set up the new type.  */
5722   current_class_name = TYPE_NAME (type);
5723   if (TREE_CODE (current_class_name) == TYPE_DECL)
5724     current_class_name = DECL_NAME (current_class_name);
5725   current_class_type = type;
5726
5727   /* By default, things in classes are private, while things in
5728      structures or unions are public.  */
5729   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5730                               ? access_private_node
5731                               : access_public_node);
5732
5733   if (previous_class_level
5734       && type != previous_class_level->this_entity
5735       && current_class_depth == 1)
5736     {
5737       /* Forcibly remove any old class remnants.  */
5738       invalidate_class_lookup_cache ();
5739     }
5740
5741   if (!previous_class_level
5742       || type != previous_class_level->this_entity
5743       || current_class_depth > 1)
5744     pushlevel_class ();
5745   else
5746     restore_class_cache ();
5747 }
5748
5749 /* When we exit a toplevel class scope, we save its binding level so
5750    that we can restore it quickly.  Here, we've entered some other
5751    class, so we must invalidate our cache.  */
5752
5753 void
5754 invalidate_class_lookup_cache (void)
5755 {
5756   previous_class_level = NULL;
5757 }
5758
5759 /* Get out of the current class scope. If we were in a class scope
5760    previously, that is the one popped to.  */
5761
5762 void
5763 popclass (void)
5764 {
5765   poplevel_class ();
5766
5767   current_class_depth--;
5768   current_class_name = current_class_stack[current_class_depth].name;
5769   current_class_type = current_class_stack[current_class_depth].type;
5770   current_access_specifier = current_class_stack[current_class_depth].access;
5771   if (current_class_stack[current_class_depth].names_used)
5772     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5773 }
5774
5775 /* Mark the top of the class stack as hidden.  */
5776
5777 void
5778 push_class_stack (void)
5779 {
5780   if (current_class_depth)
5781     ++current_class_stack[current_class_depth - 1].hidden;
5782 }
5783
5784 /* Mark the top of the class stack as un-hidden.  */
5785
5786 void
5787 pop_class_stack (void)
5788 {
5789   if (current_class_depth)
5790     --current_class_stack[current_class_depth - 1].hidden;
5791 }
5792
5793 /* Returns 1 if the class type currently being defined is either T or
5794    a nested type of T.  */
5795
5796 bool
5797 currently_open_class (tree t)
5798 {
5799   int i;
5800
5801   if (!CLASS_TYPE_P (t))
5802     return false;
5803
5804   /* We start looking from 1 because entry 0 is from global scope,
5805      and has no type.  */
5806   for (i = current_class_depth; i > 0; --i)
5807     {
5808       tree c;
5809       if (i == current_class_depth)
5810         c = current_class_type;
5811       else
5812         {
5813           if (current_class_stack[i].hidden)
5814             break;
5815           c = current_class_stack[i].type;
5816         }
5817       if (!c)
5818         continue;
5819       if (same_type_p (c, t))
5820         return true;
5821     }
5822   return false;
5823 }
5824
5825 /* If either current_class_type or one of its enclosing classes are derived
5826    from T, return the appropriate type.  Used to determine how we found
5827    something via unqualified lookup.  */
5828
5829 tree
5830 currently_open_derived_class (tree t)
5831 {
5832   int i;
5833
5834   /* The bases of a dependent type are unknown.  */
5835   if (dependent_type_p (t))
5836     return NULL_TREE;
5837
5838   if (!current_class_type)
5839     return NULL_TREE;
5840
5841   if (DERIVED_FROM_P (t, current_class_type))
5842     return current_class_type;
5843
5844   for (i = current_class_depth - 1; i > 0; --i)
5845     {
5846       if (current_class_stack[i].hidden)
5847         break;
5848       if (DERIVED_FROM_P (t, current_class_stack[i].type))
5849         return current_class_stack[i].type;
5850     }
5851
5852   return NULL_TREE;
5853 }
5854
5855 /* When entering a class scope, all enclosing class scopes' names with
5856    static meaning (static variables, static functions, types and
5857    enumerators) have to be visible.  This recursive function calls
5858    pushclass for all enclosing class contexts until global or a local
5859    scope is reached.  TYPE is the enclosed class.  */
5860
5861 void
5862 push_nested_class (tree type)
5863 {
5864   /* A namespace might be passed in error cases, like A::B:C.  */
5865   if (type == NULL_TREE
5866       || !CLASS_TYPE_P (type))
5867     return;
5868
5869   push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type)));
5870
5871   pushclass (type);
5872 }
5873
5874 /* Undoes a push_nested_class call.  */
5875
5876 void
5877 pop_nested_class (void)
5878 {
5879   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5880
5881   popclass ();
5882   if (context && CLASS_TYPE_P (context))
5883     pop_nested_class ();
5884 }
5885
5886 /* Returns the number of extern "LANG" blocks we are nested within.  */
5887
5888 int
5889 current_lang_depth (void)
5890 {
5891   return VEC_length (tree, current_lang_base);
5892 }
5893
5894 /* Set global variables CURRENT_LANG_NAME to appropriate value
5895    so that behavior of name-mangling machinery is correct.  */
5896
5897 void
5898 push_lang_context (tree name)
5899 {
5900   VEC_safe_push (tree, gc, current_lang_base, current_lang_name);
5901
5902   if (name == lang_name_cplusplus)
5903     {
5904       current_lang_name = name;
5905     }
5906   else if (name == lang_name_java)
5907     {
5908       current_lang_name = name;
5909       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5910          (See record_builtin_java_type in decl.c.)  However, that causes
5911          incorrect debug entries if these types are actually used.
5912          So we re-enable debug output after extern "Java".  */
5913       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5914       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5915       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5916       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5917       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5918       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5919       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5920       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5921     }
5922   else if (name == lang_name_c)
5923     {
5924       current_lang_name = name;
5925     }
5926   else
5927     error ("language string %<\"%E\"%> not recognized", name);
5928 }
5929
5930 /* Get out of the current language scope.  */
5931
5932 void
5933 pop_lang_context (void)
5934 {
5935   current_lang_name = VEC_pop (tree, current_lang_base);
5936 }
5937 \f
5938 /* Type instantiation routines.  */
5939
5940 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5941    matches the TARGET_TYPE.  If there is no satisfactory match, return
5942    error_mark_node, and issue an error & warning messages under
5943    control of FLAGS.  Permit pointers to member function if FLAGS
5944    permits.  If TEMPLATE_ONLY, the name of the overloaded function was
5945    a template-id, and EXPLICIT_TARGS are the explicitly provided
5946    template arguments.
5947
5948    If OVERLOAD is for one or more member functions, then ACCESS_PATH
5949    is the base path used to reference those member functions.  If
5950    TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
5951    resolved to a member function, access checks will be performed and
5952    errors issued if appropriate.  */
5953
5954 static tree
5955 resolve_address_of_overloaded_function (tree target_type,
5956                                         tree overload,
5957                                         tsubst_flags_t flags,
5958                                         bool template_only,
5959                                         tree explicit_targs,
5960                                         tree access_path)
5961 {
5962   /* Here's what the standard says:
5963
5964        [over.over]
5965
5966        If the name is a function template, template argument deduction
5967        is done, and if the argument deduction succeeds, the deduced
5968        arguments are used to generate a single template function, which
5969        is added to the set of overloaded functions considered.
5970
5971        Non-member functions and static member functions match targets of
5972        type "pointer-to-function" or "reference-to-function."  Nonstatic
5973        member functions match targets of type "pointer-to-member
5974        function;" the function type of the pointer to member is used to
5975        select the member function from the set of overloaded member
5976        functions.  If a nonstatic member function is selected, the
5977        reference to the overloaded function name is required to have the
5978        form of a pointer to member as described in 5.3.1.
5979
5980        If more than one function is selected, any template functions in
5981        the set are eliminated if the set also contains a non-template
5982        function, and any given template function is eliminated if the
5983        set contains a second template function that is more specialized
5984        than the first according to the partial ordering rules 14.5.5.2.
5985        After such eliminations, if any, there shall remain exactly one
5986        selected function.  */
5987
5988   int is_ptrmem = 0;
5989   int is_reference = 0;
5990   /* We store the matches in a TREE_LIST rooted here.  The functions
5991      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5992      interoperability with most_specialized_instantiation.  */
5993   tree matches = NULL_TREE;
5994   tree fn;
5995
5996   /* By the time we get here, we should be seeing only real
5997      pointer-to-member types, not the internal POINTER_TYPE to
5998      METHOD_TYPE representation.  */
5999   gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
6000               || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
6001
6002   gcc_assert (is_overloaded_fn (overload));
6003
6004   /* Check that the TARGET_TYPE is reasonable.  */
6005   if (TYPE_PTRFN_P (target_type))
6006     /* This is OK.  */;
6007   else if (TYPE_PTRMEMFUNC_P (target_type))
6008     /* This is OK, too.  */
6009     is_ptrmem = 1;
6010   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
6011     {
6012       /* This is OK, too.  This comes from a conversion to reference
6013          type.  */
6014       target_type = build_reference_type (target_type);
6015       is_reference = 1;
6016     }
6017   else
6018     {
6019       if (flags & tf_error)
6020         error ("cannot resolve overloaded function %qD based on"
6021                " conversion to type %qT",
6022                DECL_NAME (OVL_FUNCTION (overload)), target_type);
6023       return error_mark_node;
6024     }
6025
6026   /* If we can find a non-template function that matches, we can just
6027      use it.  There's no point in generating template instantiations
6028      if we're just going to throw them out anyhow.  But, of course, we
6029      can only do this when we don't *need* a template function.  */
6030   if (!template_only)
6031     {
6032       tree fns;
6033
6034       for (fns = overload; fns; fns = OVL_NEXT (fns))
6035         {
6036           tree fn = OVL_CURRENT (fns);
6037           tree fntype;
6038
6039           if (TREE_CODE (fn) == TEMPLATE_DECL)
6040             /* We're not looking for templates just yet.  */
6041             continue;
6042
6043           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6044               != is_ptrmem)
6045             /* We're looking for a non-static member, and this isn't
6046                one, or vice versa.  */
6047             continue;
6048
6049           /* Ignore functions which haven't been explicitly
6050              declared.  */
6051           if (DECL_ANTICIPATED (fn))
6052             continue;
6053
6054           /* See if there's a match.  */
6055           fntype = TREE_TYPE (fn);
6056           if (is_ptrmem)
6057             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
6058           else if (!is_reference)
6059             fntype = build_pointer_type (fntype);
6060
6061           if (can_convert_arg (target_type, fntype, fn, LOOKUP_NORMAL))
6062             matches = tree_cons (fn, NULL_TREE, matches);
6063         }
6064     }
6065
6066   /* Now, if we've already got a match (or matches), there's no need
6067      to proceed to the template functions.  But, if we don't have a
6068      match we need to look at them, too.  */
6069   if (!matches)
6070     {
6071       tree target_fn_type;
6072       tree target_arg_types;
6073       tree target_ret_type;
6074       tree fns;
6075       tree *args;
6076       unsigned int nargs, ia;
6077       tree arg;
6078
6079       if (is_ptrmem)
6080         target_fn_type
6081           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
6082       else
6083         target_fn_type = TREE_TYPE (target_type);
6084       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
6085       target_ret_type = TREE_TYPE (target_fn_type);
6086
6087       /* Never do unification on the 'this' parameter.  */
6088       if (TREE_CODE (target_fn_type) == METHOD_TYPE)
6089         target_arg_types = TREE_CHAIN (target_arg_types);
6090
6091       nargs = list_length (target_arg_types);
6092       args = XALLOCAVEC (tree, nargs);
6093       for (arg = target_arg_types, ia = 0;
6094            arg != NULL_TREE && arg != void_list_node;
6095            arg = TREE_CHAIN (arg), ++ia)
6096         args[ia] = TREE_VALUE (arg);
6097       nargs = ia;
6098
6099       for (fns = overload; fns; fns = OVL_NEXT (fns))
6100         {
6101           tree fn = OVL_CURRENT (fns);
6102           tree instantiation;
6103           tree instantiation_type;
6104           tree targs;
6105
6106           if (TREE_CODE (fn) != TEMPLATE_DECL)
6107             /* We're only looking for templates.  */
6108             continue;
6109
6110           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6111               != is_ptrmem)
6112             /* We're not looking for a non-static member, and this is
6113                one, or vice versa.  */
6114             continue;
6115
6116           /* Try to do argument deduction.  */
6117           targs = make_tree_vec (DECL_NTPARMS (fn));
6118           if (fn_type_unification (fn, explicit_targs, targs, args, nargs,
6119                                    target_ret_type, DEDUCE_EXACT,
6120                                    LOOKUP_NORMAL))
6121             /* Argument deduction failed.  */
6122             continue;
6123
6124           /* Instantiate the template.  */
6125           instantiation = instantiate_template (fn, targs, flags);
6126           if (instantiation == error_mark_node)
6127             /* Instantiation failed.  */
6128             continue;
6129
6130           /* See if there's a match.  */
6131           instantiation_type = TREE_TYPE (instantiation);
6132           if (is_ptrmem)
6133             instantiation_type =
6134               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
6135           else if (!is_reference)
6136             instantiation_type = build_pointer_type (instantiation_type);
6137           if (can_convert_arg (target_type, instantiation_type, instantiation,
6138                                LOOKUP_NORMAL))
6139             matches = tree_cons (instantiation, fn, matches);
6140         }
6141
6142       /* Now, remove all but the most specialized of the matches.  */
6143       if (matches)
6144         {
6145           tree match = most_specialized_instantiation (matches);
6146
6147           if (match != error_mark_node)
6148             matches = tree_cons (TREE_PURPOSE (match),
6149                                  NULL_TREE,
6150                                  NULL_TREE);
6151         }
6152     }
6153
6154   /* Now we should have exactly one function in MATCHES.  */
6155   if (matches == NULL_TREE)
6156     {
6157       /* There were *no* matches.  */
6158       if (flags & tf_error)
6159         {
6160           error ("no matches converting function %qD to type %q#T",
6161                  DECL_NAME (OVL_CURRENT (overload)),
6162                  target_type);
6163
6164           /* print_candidates expects a chain with the functions in
6165              TREE_VALUE slots, so we cons one up here (we're losing anyway,
6166              so why be clever?).  */
6167           for (; overload; overload = OVL_NEXT (overload))
6168             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
6169                                  matches);
6170
6171           print_candidates (matches);
6172         }
6173       return error_mark_node;
6174     }
6175   else if (TREE_CHAIN (matches))
6176     {
6177       /* There were too many matches.  First check if they're all
6178          the same function.  */
6179       tree match;
6180
6181       fn = TREE_PURPOSE (matches);
6182       for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match))
6183         if (!decls_match (fn, TREE_PURPOSE (matches)))
6184           break;
6185
6186       if (match)
6187         {
6188           if (flags & tf_error)
6189             {
6190               error ("converting overloaded function %qD to type %q#T is ambiguous",
6191                      DECL_NAME (OVL_FUNCTION (overload)),
6192                      target_type);
6193
6194               /* Since print_candidates expects the functions in the
6195                  TREE_VALUE slot, we flip them here.  */
6196               for (match = matches; match; match = TREE_CHAIN (match))
6197                 TREE_VALUE (match) = TREE_PURPOSE (match);
6198
6199               print_candidates (matches);
6200             }
6201
6202           return error_mark_node;
6203         }
6204     }
6205
6206   /* Good, exactly one match.  Now, convert it to the correct type.  */
6207   fn = TREE_PURPOSE (matches);
6208
6209   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
6210       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
6211     {
6212       static int explained;
6213
6214       if (!(flags & tf_error))
6215         return error_mark_node;
6216
6217       permerror (input_location, "assuming pointer to member %qD", fn);
6218       if (!explained)
6219         {
6220           inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
6221           explained = 1;
6222         }
6223     }
6224
6225   /* If we're doing overload resolution purely for the purpose of
6226      determining conversion sequences, we should not consider the
6227      function used.  If this conversion sequence is selected, the
6228      function will be marked as used at this point.  */
6229   if (!(flags & tf_conv))
6230     {
6231       /* Make =delete work with SFINAE.  */
6232       if (DECL_DELETED_FN (fn) && !(flags & tf_error))
6233         return error_mark_node;
6234
6235       mark_used (fn);
6236     }
6237
6238   /* We could not check access to member functions when this
6239      expression was originally created since we did not know at that
6240      time to which function the expression referred.  */
6241   if (!(flags & tf_no_access_control)
6242       && DECL_FUNCTION_MEMBER_P (fn))
6243     {
6244       gcc_assert (access_path);
6245       perform_or_defer_access_check (access_path, fn, fn);
6246     }
6247
6248   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
6249     return cp_build_unary_op (ADDR_EXPR, fn, 0, flags);
6250   else
6251     {
6252       /* The target must be a REFERENCE_TYPE.  Above, cp_build_unary_op
6253          will mark the function as addressed, but here we must do it
6254          explicitly.  */
6255       cxx_mark_addressable (fn);
6256
6257       return fn;
6258     }
6259 }
6260
6261 /* This function will instantiate the type of the expression given in
6262    RHS to match the type of LHSTYPE.  If errors exist, then return
6263    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
6264    we complain on errors.  If we are not complaining, never modify rhs,
6265    as overload resolution wants to try many possible instantiations, in
6266    the hope that at least one will work.
6267
6268    For non-recursive calls, LHSTYPE should be a function, pointer to
6269    function, or a pointer to member function.  */
6270
6271 tree
6272 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6273 {
6274   tsubst_flags_t flags_in = flags;
6275   tree access_path = NULL_TREE;
6276
6277   flags &= ~tf_ptrmem_ok;
6278
6279   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
6280     {
6281       if (flags & tf_error)
6282         error ("not enough type information");
6283       return error_mark_node;
6284     }
6285
6286   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6287     {
6288       if (same_type_p (lhstype, TREE_TYPE (rhs)))
6289         return rhs;
6290       if (flag_ms_extensions
6291           && TYPE_PTRMEMFUNC_P (lhstype)
6292           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6293         /* Microsoft allows `A::f' to be resolved to a
6294            pointer-to-member.  */
6295         ;
6296       else
6297         {
6298           if (flags & tf_error)
6299             error ("argument of type %qT does not match %qT",
6300                    TREE_TYPE (rhs), lhstype);
6301           return error_mark_node;
6302         }
6303     }
6304
6305   if (TREE_CODE (rhs) == BASELINK)
6306     {
6307       access_path = BASELINK_ACCESS_BINFO (rhs);
6308       rhs = BASELINK_FUNCTIONS (rhs);
6309     }
6310
6311   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6312      deduce any type information.  */
6313   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6314     {
6315       if (flags & tf_error)
6316         error ("not enough type information");
6317       return error_mark_node;
6318     }
6319
6320   /* There only a few kinds of expressions that may have a type
6321      dependent on overload resolution.  */
6322   gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6323               || TREE_CODE (rhs) == COMPONENT_REF
6324               || really_overloaded_fn (rhs)
6325               || (flag_ms_extensions && TREE_CODE (rhs) == FUNCTION_DECL));
6326
6327   /* This should really only be used when attempting to distinguish
6328      what sort of a pointer to function we have.  For now, any
6329      arithmetic operation which is not supported on pointers
6330      is rejected as an error.  */
6331
6332   switch (TREE_CODE (rhs))
6333     {
6334     case COMPONENT_REF:
6335       {
6336         tree member = TREE_OPERAND (rhs, 1);
6337
6338         member = instantiate_type (lhstype, member, flags);
6339         if (member != error_mark_node
6340             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6341           /* Do not lose object's side effects.  */
6342           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6343                          TREE_OPERAND (rhs, 0), member);
6344         return member;
6345       }
6346
6347     case OFFSET_REF:
6348       rhs = TREE_OPERAND (rhs, 1);
6349       if (BASELINK_P (rhs))
6350         return instantiate_type (lhstype, rhs, flags_in);
6351
6352       /* This can happen if we are forming a pointer-to-member for a
6353          member template.  */
6354       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6355
6356       /* Fall through.  */
6357
6358     case TEMPLATE_ID_EXPR:
6359       {
6360         tree fns = TREE_OPERAND (rhs, 0);
6361         tree args = TREE_OPERAND (rhs, 1);
6362
6363         return
6364           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6365                                                   /*template_only=*/true,
6366                                                   args, access_path);
6367       }
6368
6369     case OVERLOAD:
6370     case FUNCTION_DECL:
6371       return
6372         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6373                                                 /*template_only=*/false,
6374                                                 /*explicit_targs=*/NULL_TREE,
6375                                                 access_path);
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"