gcc/cp/class.c

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