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