gcc/cp/class.c

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