gcc/cp/class.c

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