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