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 (cp_unevaluated_operand != 0)
 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 (input_location, vtbl, idx);
 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       cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
 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_OR_ENUMERATION_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 (input_location,
3640                          FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3641       DECL_ARTIFICIAL (decl) = 1;
3642       DECL_IGNORED_P (decl) = 1;
3643       DECL_FIELD_CONTEXT (decl) = t;
3644       if (CLASSTYPE_AS_BASE (basetype))
3645         {
3646           DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3647           DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3648           DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3649           DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3650           DECL_MODE (decl) = TYPE_MODE (basetype);
3651           DECL_FIELD_IS_BASE (decl) = 1;
3652
3653           /* Try to place the field.  It may take more than one try if we
3654              have a hard time placing the field without putting two
3655              objects of the same type at the same address.  */
3656           layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3657           /* Add the new FIELD_DECL to the list of fields for T.  */
3658           TREE_CHAIN (decl) = *next_field;
3659           *next_field = decl;
3660           next_field = &TREE_CHAIN (decl);
3661         }
3662     }
3663   else
3664     {
3665       tree eoc;
3666       bool atend;
3667
3668       /* On some platforms (ARM), even empty classes will not be
3669          byte-aligned.  */
3670       eoc = round_up (rli_size_unit_so_far (rli),
3671                       CLASSTYPE_ALIGN_UNIT (basetype));
3672       atend = layout_empty_base (rli, binfo, eoc, offsets);
3673       /* A nearly-empty class "has no proper base class that is empty,
3674          not morally virtual, and at an offset other than zero."  */
3675       if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3676         {
3677           if (atend)
3678             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3679           /* The check above (used in G++ 3.2) is insufficient because
3680              an empty class placed at offset zero might itself have an
3681              empty base at a nonzero offset.  */
3682           else if (walk_subobject_offsets (basetype,
3683                                            empty_base_at_nonzero_offset_p,
3684                                            size_zero_node,
3685                                            /*offsets=*/NULL,
3686                                            /*max_offset=*/NULL_TREE,
3687                                            /*vbases_p=*/true))
3688             {
3689               if (abi_version_at_least (2))
3690                 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3691               else
3692                 warning (OPT_Wabi,
3693                          "class %qT will be considered nearly empty in a "
3694                          "future version of GCC", t);
3695             }
3696         }
3697
3698       /* We do not create a FIELD_DECL for empty base classes because
3699          it might overlap some other field.  We want to be able to
3700          create CONSTRUCTORs for the class by iterating over the
3701          FIELD_DECLs, and the back end does not handle overlapping
3702          FIELD_DECLs.  */
3703
3704       /* An empty virtual base causes a class to be non-empty
3705          -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3706          here because that was already done when the virtual table
3707          pointer was created.  */
3708     }
3709
3710   /* Record the offsets of BINFO and its base subobjects.  */
3711   record_subobject_offsets (binfo,
3712                             BINFO_OFFSET (binfo),
3713                             offsets,
3714                             /*is_data_member=*/false);
3715
3716   return next_field;
3717 }
3718
3719 /* Layout all of the non-virtual base classes.  Record empty
3720    subobjects in OFFSETS.  T is the most derived type.  Return nonzero
3721    if the type cannot be nearly empty.  The fields created
3722    corresponding to the base classes will be inserted at
3723    *NEXT_FIELD.  */
3724
3725 static void
3726 build_base_fields (record_layout_info rli,
3727                    splay_tree offsets, tree *next_field)
3728 {
3729   /* Chain to hold all the new FIELD_DECLs which stand in for base class
3730      subobjects.  */
3731   tree t = rli->t;
3732   int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
3733   int i;
3734
3735   /* The primary base class is always allocated first.  */
3736   if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3737     next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3738                                    offsets, next_field);
3739
3740   /* Now allocate the rest of the bases.  */
3741   for (i = 0; i < n_baseclasses; ++i)
3742     {
3743       tree base_binfo;
3744
3745       base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
3746
3747       /* The primary base was already allocated above, so we don't
3748          need to allocate it again here.  */
3749       if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3750         continue;
3751
3752       /* Virtual bases are added at the end (a primary virtual base
3753          will have already been added).  */
3754       if (BINFO_VIRTUAL_P (base_binfo))
3755         continue;
3756
3757       next_field = build_base_field (rli, base_binfo,
3758                                      offsets, next_field);
3759     }
3760 }
3761
3762 /* Go through the TYPE_METHODS of T issuing any appropriate
3763    diagnostics, figuring out which methods override which other
3764    methods, and so forth.  */
3765
3766 static void
3767 check_methods (tree t)
3768 {
3769   tree x;
3770
3771   for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3772     {
3773       check_for_override (x, t);
3774       if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3775         error ("initializer specified for non-virtual method %q+D", x);
3776       /* The name of the field is the original field name
3777          Save this in auxiliary field for later overloading.  */
3778       if (DECL_VINDEX (x))
3779         {
3780           TYPE_POLYMORPHIC_P (t) = 1;
3781           if (DECL_PURE_VIRTUAL_P (x))
3782             VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
3783         }
3784       /* All user-provided destructors are non-trivial.  */
3785       if (DECL_DESTRUCTOR_P (x) && !DECL_DEFAULTED_FN (x))
3786         TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 1;
3787     }
3788 }
3789
3790 /* FN is a constructor or destructor.  Clone the declaration to create
3791    a specialized in-charge or not-in-charge version, as indicated by
3792    NAME.  */
3793
3794 static tree
3795 build_clone (tree fn, tree name)
3796 {
3797   tree parms;
3798   tree clone;
3799
3800   /* Copy the function.  */
3801   clone = copy_decl (fn);
3802   /* Remember where this function came from.  */
3803   DECL_CLONED_FUNCTION (clone) = fn;
3804   DECL_ABSTRACT_ORIGIN (clone) = fn;
3805   /* Reset the function name.  */
3806   DECL_NAME (clone) = name;
3807   SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3808   /* There's no pending inline data for this function.  */
3809   DECL_PENDING_INLINE_INFO (clone) = NULL;
3810   DECL_PENDING_INLINE_P (clone) = 0;
3811   /* And it hasn't yet been deferred.  */
3812   DECL_DEFERRED_FN (clone) = 0;
3813
3814   /* The base-class destructor is not virtual.  */
3815   if (name == base_dtor_identifier)
3816     {
3817       DECL_VIRTUAL_P (clone) = 0;
3818       if (TREE_CODE (clone) != TEMPLATE_DECL)
3819         DECL_VINDEX (clone) = NULL_TREE;
3820     }
3821
3822   /* If there was an in-charge parameter, drop it from the function
3823      type.  */
3824   if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3825     {
3826       tree basetype;
3827       tree parmtypes;
3828       tree exceptions;
3829
3830       exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3831       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3832       parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
3833       /* Skip the `this' parameter.  */
3834       parmtypes = TREE_CHAIN (parmtypes);
3835       /* Skip the in-charge parameter.  */
3836       parmtypes = TREE_CHAIN (parmtypes);
3837       /* And the VTT parm, in a complete [cd]tor.  */
3838       if (DECL_HAS_VTT_PARM_P (fn)
3839           && ! DECL_NEEDS_VTT_PARM_P (clone))
3840         parmtypes = TREE_CHAIN (parmtypes);
3841        /* If this is subobject constructor or destructor, add the vtt
3842          parameter.  */
3843       TREE_TYPE (clone)
3844         = build_method_type_directly (basetype,
3845                                       TREE_TYPE (TREE_TYPE (clone)),
3846                                       parmtypes);
3847       if (exceptions)
3848         TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
3849                                                      exceptions);
3850       TREE_TYPE (clone)
3851         = cp_build_type_attribute_variant (TREE_TYPE (clone),
3852                                            TYPE_ATTRIBUTES (TREE_TYPE (fn)));
3853     }
3854
3855   /* Copy the function parameters.  But, DECL_ARGUMENTS on a TEMPLATE_DECL
3856      aren't function parameters; those are the template parameters.  */
3857   if (TREE_CODE (clone) != TEMPLATE_DECL)
3858     {
3859       DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
3860       /* Remove the in-charge parameter.  */
3861       if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3862         {
3863           TREE_CHAIN (DECL_ARGUMENTS (clone))
3864             = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3865           DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
3866         }
3867       /* And the VTT parm, in a complete [cd]tor.  */
3868       if (DECL_HAS_VTT_PARM_P (fn))
3869         {
3870           if (DECL_NEEDS_VTT_PARM_P (clone))
3871             DECL_HAS_VTT_PARM_P (clone) = 1;
3872           else
3873             {
3874               TREE_CHAIN (DECL_ARGUMENTS (clone))
3875                 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3876               DECL_HAS_VTT_PARM_P (clone) = 0;
3877             }
3878         }
3879
3880       for (parms = DECL_ARGUMENTS (clone); parms; parms = TREE_CHAIN (parms))
3881         {
3882           DECL_CONTEXT (parms) = clone;
3883           cxx_dup_lang_specific_decl (parms);
3884         }
3885     }
3886
3887   /* Create the RTL for this function.  */
3888   SET_DECL_RTL (clone, NULL_RTX);
3889   rest_of_decl_compilation (clone, /*top_level=*/1, at_eof);
3890
3891   /* Make it easy to find the CLONE given the FN.  */
3892   TREE_CHAIN (clone) = TREE_CHAIN (fn);
3893   TREE_CHAIN (fn) = clone;
3894
3895   /* If this is a template, handle the DECL_TEMPLATE_RESULT as well.  */
3896   if (TREE_CODE (clone) == TEMPLATE_DECL)
3897     {
3898       tree result;
3899
3900       DECL_TEMPLATE_RESULT (clone)
3901         = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3902       result = DECL_TEMPLATE_RESULT (clone);
3903       DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3904       DECL_TI_TEMPLATE (result) = clone;
3905     }
3906   else if (pch_file)
3907     note_decl_for_pch (clone);
3908
3909   return clone;
3910 }
3911
3912 /* Produce declarations for all appropriate clones of FN.  If
3913    UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
3914    CLASTYPE_METHOD_VEC as well.  */
3915
3916 void
3917 clone_function_decl (tree fn, int update_method_vec_p)
3918 {
3919   tree clone;
3920
3921   /* Avoid inappropriate cloning.  */
3922   if (TREE_CHAIN (fn)
3923       && DECL_CLONED_FUNCTION (TREE_CHAIN (fn)))
3924     return;
3925
3926   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
3927     {
3928       /* For each constructor, we need two variants: an in-charge version
3929          and a not-in-charge version.  */
3930       clone = build_clone (fn, complete_ctor_identifier);
3931       if (update_method_vec_p)
3932         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3933       clone = build_clone (fn, base_ctor_identifier);
3934       if (update_method_vec_p)
3935         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3936     }
3937   else
3938     {
3939       gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn));
3940
3941       /* For each destructor, we need three variants: an in-charge
3942          version, a not-in-charge version, and an in-charge deleting
3943          version.  We clone the deleting version first because that
3944          means it will go second on the TYPE_METHODS list -- and that
3945          corresponds to the correct layout order in the virtual
3946          function table.
3947
3948          For a non-virtual destructor, we do not build a deleting
3949          destructor.  */
3950       if (DECL_VIRTUAL_P (fn))
3951         {
3952           clone = build_clone (fn, deleting_dtor_identifier);
3953           if (update_method_vec_p)
3954             add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3955         }
3956       clone = build_clone (fn, complete_dtor_identifier);
3957       if (update_method_vec_p)
3958         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3959       clone = build_clone (fn, base_dtor_identifier);
3960       if (update_method_vec_p)
3961         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
3962     }
3963
3964   /* Note that this is an abstract function that is never emitted.  */
3965   DECL_ABSTRACT (fn) = 1;
3966 }
3967
3968 /* DECL is an in charge constructor, which is being defined. This will
3969    have had an in class declaration, from whence clones were
3970    declared. An out-of-class definition can specify additional default
3971    arguments. As it is the clones that are involved in overload
3972    resolution, we must propagate the information from the DECL to its
3973    clones.  */
3974
3975 void
3976 adjust_clone_args (tree decl)
3977 {
3978   tree clone;
3979
3980   for (clone = TREE_CHAIN (decl); clone && DECL_CLONED_FUNCTION (clone);
3981        clone = TREE_CHAIN (clone))
3982     {
3983       tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone));
3984       tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
3985       tree decl_parms, clone_parms;
3986
3987       clone_parms = orig_clone_parms;
3988
3989       /* Skip the 'this' parameter.  */
3990       orig_clone_parms = TREE_CHAIN (orig_clone_parms);
3991       orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3992
3993       if (DECL_HAS_IN_CHARGE_PARM_P (decl))
3994         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3995       if (DECL_HAS_VTT_PARM_P (decl))
3996         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3997
3998       clone_parms = orig_clone_parms;
3999       if (DECL_HAS_VTT_PARM_P (clone))
4000         clone_parms = TREE_CHAIN (clone_parms);
4001
4002       for (decl_parms = orig_decl_parms; decl_parms;
4003            decl_parms = TREE_CHAIN (decl_parms),
4004              clone_parms = TREE_CHAIN (clone_parms))
4005         {
4006           gcc_assert (same_type_p (TREE_TYPE (decl_parms),
4007                                    TREE_TYPE (clone_parms)));
4008
4009           if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
4010             {
4011               /* A default parameter has been added. Adjust the
4012                  clone's parameters.  */
4013               tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
4014               tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
4015               tree type;
4016
4017               clone_parms = orig_decl_parms;
4018
4019               if (DECL_HAS_VTT_PARM_P (clone))
4020                 {
4021                   clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
4022                                            TREE_VALUE (orig_clone_parms),
4023                                            clone_parms);
4024                   TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
4025                 }
4026               type = build_method_type_directly (basetype,
4027                                                  TREE_TYPE (TREE_TYPE (clone)),
4028                                                  clone_parms);
4029               if (exceptions)
4030                 type = build_exception_variant (type, exceptions);
4031               TREE_TYPE (clone) = type;
4032
4033               clone_parms = NULL_TREE;
4034               break;
4035             }
4036         }
4037       gcc_assert (!clone_parms);
4038     }
4039 }
4040
4041 /* For each of the constructors and destructors in T, create an
4042    in-charge and not-in-charge variant.  */
4043
4044 static void
4045 clone_constructors_and_destructors (tree t)
4046 {
4047   tree fns;
4048
4049   /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4050      out now.  */
4051   if (!CLASSTYPE_METHOD_VEC (t))
4052     return;
4053
4054   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4055     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4056   for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4057     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4058 }
4059
4060 /* Returns true iff class T has a user-defined constructor other than
4061    the default constructor.  */
4062
4063 bool
4064 type_has_user_nondefault_constructor (tree t)
4065 {
4066   tree fns;
4067
4068   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4069     return false;
4070
4071   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4072     {
4073       tree fn = OVL_CURRENT (fns);
4074       if (!DECL_ARTIFICIAL (fn)
4075           && (TREE_CODE (fn) == TEMPLATE_DECL
4076               || (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn))
4077                   != NULL_TREE)))
4078         return true;
4079     }
4080
4081   return false;
4082 }
4083
4084 /* Returns true iff FN is a user-provided function, i.e. user-declared
4085    and not defaulted at its first declaration.  */
4086
4087 static bool
4088 user_provided_p (tree fn)
4089 {
4090   if (TREE_CODE (fn) == TEMPLATE_DECL)
4091     return true;
4092   else
4093     return (!DECL_ARTIFICIAL (fn)
4094             && !(DECL_DEFAULTED_FN (fn)
4095                  && DECL_INITIALIZED_IN_CLASS_P (fn)));
4096 }
4097
4098 /* Returns true iff class T has a user-provided constructor.  */
4099
4100 bool
4101 type_has_user_provided_constructor (tree t)
4102 {
4103   tree fns;
4104
4105   if (!CLASS_TYPE_P (t))
4106     return false;
4107
4108   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4109     return false;
4110
4111   /* This can happen in error cases; avoid crashing.  */
4112   if (!CLASSTYPE_METHOD_VEC (t))
4113     return false;
4114
4115   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4116     if (user_provided_p (OVL_CURRENT (fns)))
4117       return true;
4118
4119   return false;
4120 }
4121
4122 /* Returns true iff class T has a user-provided default constructor.  */
4123
4124 bool
4125 type_has_user_provided_default_constructor (tree t)
4126 {
4127   tree fns, args;
4128
4129   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4130     return false;
4131
4132   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4133     {
4134       tree fn = OVL_CURRENT (fns);
4135       if (TREE_CODE (fn) == FUNCTION_DECL
4136           && user_provided_p (fn))
4137         {
4138           args = FUNCTION_FIRST_USER_PARMTYPE (fn);
4139           while (args && TREE_PURPOSE (args))
4140             args = TREE_CHAIN (args);
4141           if (!args || args == void_list_node)
4142             return true;
4143         }
4144     }
4145
4146   return false;
4147 }
4148
4149 /* Returns true if FN can be explicitly defaulted.  */
4150
4151 bool
4152 defaultable_fn_p (tree fn)
4153 {
4154   if (DECL_CONSTRUCTOR_P (fn))
4155     {
4156       if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
4157         return true;
4158       else if (copy_fn_p (fn) > 0
4159                && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
4160                    == void_list_node))
4161         return true;
4162       else
4163         return false;
4164     }
4165   else if (DECL_DESTRUCTOR_P (fn))
4166     return true;
4167   else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
4168            && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
4169     return copy_fn_p (fn);
4170   else
4171     return false;
4172 }
4173
4174 /* Remove all zero-width bit-fields from T.  */
4175
4176 static void
4177 remove_zero_width_bit_fields (tree t)
4178 {
4179   tree *fieldsp;
4180
4181   fieldsp = &TYPE_FIELDS (t);
4182   while (*fieldsp)
4183     {
4184       if (TREE_CODE (*fieldsp) == FIELD_DECL
4185           && DECL_C_BIT_FIELD (*fieldsp)
4186           && DECL_INITIAL (*fieldsp))
4187         *fieldsp = TREE_CHAIN (*fieldsp);
4188       else
4189         fieldsp = &TREE_CHAIN (*fieldsp);
4190     }
4191 }
4192
4193 /* Returns TRUE iff we need a cookie when dynamically allocating an
4194    array whose elements have the indicated class TYPE.  */
4195
4196 static bool
4197 type_requires_array_cookie (tree type)
4198 {
4199   tree fns;
4200   bool has_two_argument_delete_p = false;
4201
4202   gcc_assert (CLASS_TYPE_P (type));
4203
4204   /* If there's a non-trivial destructor, we need a cookie.  In order
4205      to iterate through the array calling the destructor for each
4206      element, we'll have to know how many elements there are.  */
4207   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4208     return true;
4209
4210   /* If the usual deallocation function is a two-argument whose second
4211      argument is of type `size_t', then we have to pass the size of
4212      the array to the deallocation function, so we will need to store
4213      a cookie.  */
4214   fns = lookup_fnfields (TYPE_BINFO (type),
4215                          ansi_opname (VEC_DELETE_EXPR),
4216                          /*protect=*/0);
4217   /* If there are no `operator []' members, or the lookup is
4218      ambiguous, then we don't need a cookie.  */
4219   if (!fns || fns == error_mark_node)
4220     return false;
4221   /* Loop through all of the functions.  */
4222   for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4223     {
4224       tree fn;
4225       tree second_parm;
4226
4227       /* Select the current function.  */
4228       fn = OVL_CURRENT (fns);
4229       /* See if this function is a one-argument delete function.  If
4230          it is, then it will be the usual deallocation function.  */
4231       second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4232       if (second_parm == void_list_node)
4233         return false;
4234       /* Do not consider this function if its second argument is an
4235          ellipsis.  */
4236       if (!second_parm)
4237         continue;
4238       /* Otherwise, if we have a two-argument function and the second
4239          argument is `size_t', it will be the usual deallocation
4240          function -- unless there is one-argument function, too.  */
4241       if (TREE_CHAIN (second_parm) == void_list_node
4242           && same_type_p (TREE_VALUE (second_parm), size_type_node))
4243         has_two_argument_delete_p = true;
4244     }
4245
4246   return has_two_argument_delete_p;
4247 }
4248
4249 /* Check the validity of the bases and members declared in T.  Add any
4250    implicitly-generated functions (like copy-constructors and
4251    assignment operators).  Compute various flag bits (like
4252    CLASSTYPE_NON_POD_T) for T.  This routine works purely at the C++
4253    level: i.e., independently of the ABI in use.  */
4254
4255 static void
4256 check_bases_and_members (tree t)
4257 {
4258   /* Nonzero if the implicitly generated copy constructor should take
4259      a non-const reference argument.  */
4260   int cant_have_const_ctor;
4261   /* Nonzero if the implicitly generated assignment operator
4262      should take a non-const reference argument.  */
4263   int no_const_asn_ref;
4264   tree access_decls;
4265   bool saved_complex_asn_ref;
4266   bool saved_nontrivial_dtor;
4267
4268   /* By default, we use const reference arguments and generate default
4269      constructors.  */
4270   cant_have_const_ctor = 0;
4271   no_const_asn_ref = 0;
4272
4273   /* Check all the base-classes.  */
4274   check_bases (t, &cant_have_const_ctor,
4275                &no_const_asn_ref);
4276
4277   /* Check all the method declarations.  */
4278   check_methods (t);
4279
4280   /* Save the initial values of these flags which only indicate whether
4281      or not the class has user-provided functions.  As we analyze the
4282      bases and members we can set these flags for other reasons.  */
4283   saved_complex_asn_ref = TYPE_HAS_COMPLEX_ASSIGN_REF (t);
4284   saved_nontrivial_dtor = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
4285
4286   /* Check all the data member declarations.  We cannot call
4287      check_field_decls until we have called check_bases check_methods,
4288      as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4289      being set appropriately.  */
4290   check_field_decls (t, &access_decls,
4291                      &cant_have_const_ctor,
4292                      &no_const_asn_ref);
4293
4294   /* A nearly-empty class has to be vptr-containing; a nearly empty
4295      class contains just a vptr.  */
4296   if (!TYPE_CONTAINS_VPTR_P (t))
4297     CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4298
4299   /* Do some bookkeeping that will guide the generation of implicitly
4300      declared member functions.  */
4301   TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_CONTAINS_VPTR_P (t);
4302   /* We need to call a constructor for this class if it has a
4303      user-provided constructor, or if the default constructor is going
4304      to initialize the vptr.  (This is not an if-and-only-if;
4305      TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
4306      themselves need constructing.)  */
4307   TYPE_NEEDS_CONSTRUCTING (t)
4308     |= (type_has_user_provided_constructor (t) || TYPE_CONTAINS_VPTR_P (t));
4309   /* [dcl.init.aggr]
4310
4311      An aggregate is an array or a class with no user-provided
4312      constructors ... and no virtual functions.
4313
4314      Again, other conditions for being an aggregate are checked
4315      elsewhere.  */
4316   CLASSTYPE_NON_AGGREGATE (t)
4317     |= (type_has_user_provided_constructor (t) || TYPE_POLYMORPHIC_P (t));
4318   CLASSTYPE_NON_POD_P (t)
4319     |= (CLASSTYPE_NON_AGGREGATE (t)
4320         || saved_nontrivial_dtor || saved_complex_asn_ref);
4321   TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_CONTAINS_VPTR_P (t);
4322   TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_CONTAINS_VPTR_P (t);
4323
4324   /* If the class has no user-declared constructor, but does have
4325      non-static const or reference data members that can never be
4326      initialized, issue a warning.  */
4327   if (warn_uninitialized
4328       /* Classes with user-declared constructors are presumed to
4329          initialize these members.  */
4330       && !TYPE_HAS_USER_CONSTRUCTOR (t)
4331       /* Aggregates can be initialized with brace-enclosed
4332          initializers.  */
4333       && CLASSTYPE_NON_AGGREGATE (t))
4334     {
4335       tree field;
4336
4337       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4338         {
4339           tree type;
4340
4341           if (TREE_CODE (field) != FIELD_DECL)
4342             continue;
4343
4344           type = TREE_TYPE (field);
4345           if (TREE_CODE (type) == REFERENCE_TYPE)
4346             warning (OPT_Wuninitialized, "non-static reference %q+#D "
4347                      "in class without a constructor", field);
4348           else if (CP_TYPE_CONST_P (type)
4349                    && (!CLASS_TYPE_P (type)
4350                        || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4351             warning (OPT_Wuninitialized, "non-static const member %q+#D "
4352                      "in class without a constructor", field);
4353         }
4354     }
4355
4356   /* Synthesize any needed methods.  */
4357   add_implicitly_declared_members (t,
4358                                    cant_have_const_ctor,
4359                                    no_const_asn_ref);
4360
4361   /* Create the in-charge and not-in-charge variants of constructors
4362      and destructors.  */
4363   clone_constructors_and_destructors (t);
4364
4365   /* Process the using-declarations.  */
4366   for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4367     handle_using_decl (TREE_VALUE (access_decls), t);
4368
4369   /* Build and sort the CLASSTYPE_METHOD_VEC.  */
4370   finish_struct_methods (t);
4371
4372   /* Figure out whether or not we will need a cookie when dynamically
4373      allocating an array of this type.  */
4374   TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4375     = type_requires_array_cookie (t);
4376 }
4377
4378 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4379    accordingly.  If a new vfield was created (because T doesn't have a
4380    primary base class), then the newly created field is returned.  It
4381    is not added to the TYPE_FIELDS list; it is the caller's
4382    responsibility to do that.  Accumulate declared virtual functions
4383    on VIRTUALS_P.  */
4384
4385 static tree
4386 create_vtable_ptr (tree t, tree* virtuals_p)
4387 {
4388   tree fn;
4389
4390   /* Collect the virtual functions declared in T.  */
4391   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4392     if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4393         && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4394       {
4395         tree new_virtual = make_node (TREE_LIST);
4396
4397         BV_FN (new_virtual) = fn;
4398         BV_DELTA (new_virtual) = integer_zero_node;
4399         BV_VCALL_INDEX (new_virtual) = NULL_TREE;
4400
4401         TREE_CHAIN (new_virtual) = *virtuals_p;
4402         *virtuals_p = new_virtual;
4403       }
4404
4405   /* If we couldn't find an appropriate base class, create a new field
4406      here.  Even if there weren't any new virtual functions, we might need a
4407      new virtual function table if we're supposed to include vptrs in
4408      all classes that need them.  */
4409   if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4410     {
4411       /* We build this decl with vtbl_ptr_type_node, which is a
4412          `vtable_entry_type*'.  It might seem more precise to use
4413          `vtable_entry_type (*)[N]' where N is the number of virtual
4414          functions.  However, that would require the vtable pointer in
4415          base classes to have a different type than the vtable pointer
4416          in derived classes.  We could make that happen, but that
4417          still wouldn't solve all the problems.  In particular, the
4418          type-based alias analysis code would decide that assignments
4419          to the base class vtable pointer can't alias assignments to
4420          the derived class vtable pointer, since they have different
4421          types.  Thus, in a derived class destructor, where the base
4422          class constructor was inlined, we could generate bad code for
4423          setting up the vtable pointer.
4424
4425          Therefore, we use one type for all vtable pointers.  We still
4426          use a type-correct type; it's just doesn't indicate the array
4427          bounds.  That's better than using `void*' or some such; it's
4428          cleaner, and it let's the alias analysis code know that these
4429          stores cannot alias stores to void*!  */
4430       tree field;
4431
4432       field = build_decl (input_location,
4433                           FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4434       DECL_VIRTUAL_P (field) = 1;
4435       DECL_ARTIFICIAL (field) = 1;
4436       DECL_FIELD_CONTEXT (field) = t;
4437       DECL_FCONTEXT (field) = t;
4438
4439       TYPE_VFIELD (t) = field;
4440
4441       /* This class is non-empty.  */
4442       CLASSTYPE_EMPTY_P (t) = 0;
4443
4444       return field;
4445     }
4446
4447   return NULL_TREE;
4448 }
4449
4450 /* Fixup the inline function given by INFO now that the class is
4451    complete.  */
4452
4453 static void
4454 fixup_pending_inline (tree fn)
4455 {
4456   if (DECL_PENDING_INLINE_INFO (fn))
4457     {
4458       tree args = DECL_ARGUMENTS (fn);
4459       while (args)
4460         {
4461           DECL_CONTEXT (args) = fn;
4462           args = TREE_CHAIN (args);
4463         }
4464     }
4465 }
4466
4467 /* Fixup the inline methods and friends in TYPE now that TYPE is
4468    complete.  */
4469
4470 static void
4471 fixup_inline_methods (tree type)
4472 {
4473   tree method = TYPE_METHODS (type);
4474   VEC(tree,gc) *friends;
4475   unsigned ix;
4476
4477   if (method && TREE_CODE (method) == TREE_VEC)
4478     {
4479       if (TREE_VEC_ELT (method, 1))
4480         method = TREE_VEC_ELT (method, 1);
4481       else if (TREE_VEC_ELT (method, 0))
4482         method = TREE_VEC_ELT (method, 0);
4483       else
4484         method = TREE_VEC_ELT (method, 2);
4485     }
4486
4487   /* Do inline member functions.  */
4488   for (; method; method = TREE_CHAIN (method))
4489     fixup_pending_inline (method);
4490
4491   /* Do friends.  */
4492   for (friends = CLASSTYPE_INLINE_FRIENDS (type), ix = 0;
4493        VEC_iterate (tree, friends, ix, method); ix++)
4494     fixup_pending_inline (method);
4495   CLASSTYPE_INLINE_FRIENDS (type) = NULL;
4496 }
4497
4498 /* Add OFFSET to all base types of BINFO which is a base in the
4499    hierarchy dominated by T.
4500
4501    OFFSET, which is a type offset, is number of bytes.  */
4502
4503 static void
4504 propagate_binfo_offsets (tree binfo, tree offset)
4505 {
4506   int i;
4507   tree primary_binfo;
4508   tree base_binfo;
4509
4510   /* Update BINFO's offset.  */
4511   BINFO_OFFSET (binfo)
4512     = convert (sizetype,
4513                size_binop (PLUS_EXPR,
4514                            convert (ssizetype, BINFO_OFFSET (binfo)),
4515                            offset));
4516
4517   /* Find the primary base class.  */
4518   primary_binfo = get_primary_binfo (binfo);
4519
4520   if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo)
4521     propagate_binfo_offsets (primary_binfo, offset);
4522
4523   /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4524      downwards.  */
4525   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4526     {
4527       /* Don't do the primary base twice.  */
4528       if (base_binfo == primary_binfo)
4529         continue;
4530
4531       if (BINFO_VIRTUAL_P (base_binfo))
4532         continue;
4533
4534       propagate_binfo_offsets (base_binfo, offset);
4535     }
4536 }
4537
4538 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T.  Update
4539    TYPE_ALIGN and TYPE_SIZE for T.  OFFSETS gives the location of
4540    empty subobjects of T.  */
4541
4542 static void
4543 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4544 {
4545   tree vbase;
4546   tree t = rli->t;
4547   bool first_vbase = true;
4548   tree *next_field;
4549
4550   if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0)
4551     return;
4552
4553   if (!abi_version_at_least(2))
4554     {
4555       /* In G++ 3.2, we incorrectly rounded the size before laying out
4556          the virtual bases.  */
4557       finish_record_layout (rli, /*free_p=*/false);
4558 #ifdef STRUCTURE_SIZE_BOUNDARY
4559       /* Packed structures don't need to have minimum size.  */
4560       if (! TYPE_PACKED (t))
4561         TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
4562 #endif
4563       rli->offset = TYPE_SIZE_UNIT (t);
4564       rli->bitpos = bitsize_zero_node;
4565       rli->record_align = TYPE_ALIGN (t);
4566     }
4567
4568   /* Find the last field.  The artificial fields created for virtual
4569      bases will go after the last extant field to date.  */
4570   next_field = &TYPE_FIELDS (t);
4571   while (*next_field)
4572     next_field = &TREE_CHAIN (*next_field);
4573
4574   /* Go through the virtual bases, allocating space for each virtual
4575      base that is not already a primary base class.  These are
4576      allocated in inheritance graph order.  */
4577   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
4578     {
4579       if (!BINFO_VIRTUAL_P (vbase))
4580         continue;
4581
4582       if (!BINFO_PRIMARY_P (vbase))
4583         {
4584           tree basetype = TREE_TYPE (vbase);
4585
4586           /* This virtual base is not a primary base of any class in the
4587              hierarchy, so we have to add space for it.  */
4588           next_field = build_base_field (rli, vbase,
4589                                          offsets, next_field);
4590
4591           /* If the first virtual base might have been placed at a
4592              lower address, had we started from CLASSTYPE_SIZE, rather
4593              than TYPE_SIZE, issue a warning.  There can be both false
4594              positives and false negatives from this warning in rare
4595              cases; to deal with all the possibilities would probably
4596              require performing both layout algorithms and comparing
4597              the results which is not particularly tractable.  */
4598           if (warn_abi
4599               && first_vbase
4600               && (tree_int_cst_lt
4601                   (size_binop (CEIL_DIV_EXPR,
4602                                round_up (CLASSTYPE_SIZE (t),
4603                                          CLASSTYPE_ALIGN (basetype)),
4604                                bitsize_unit_node),
4605                    BINFO_OFFSET (vbase))))
4606             warning (OPT_Wabi,
4607                      "offset of virtual base %qT is not ABI-compliant and "
4608                      "may change in a future version of GCC",
4609                      basetype);
4610
4611           first_vbase = false;
4612         }
4613     }
4614 }
4615
4616 /* Returns the offset of the byte just past the end of the base class
4617    BINFO.  */
4618
4619 static tree
4620 end_of_base (tree binfo)
4621 {
4622   tree size;
4623
4624   if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo)))
4625     size = TYPE_SIZE_UNIT (char_type_node);
4626   else if (is_empty_class (BINFO_TYPE (binfo)))
4627     /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4628        allocate some space for it. It cannot have virtual bases, so
4629        TYPE_SIZE_UNIT is fine.  */
4630     size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4631   else
4632     size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4633
4634   return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
4635 }
4636
4637 /* Returns the offset of the byte just past the end of the base class
4638    with the highest offset in T.  If INCLUDE_VIRTUALS_P is zero, then
4639    only non-virtual bases are included.  */
4640
4641 static tree
4642 end_of_class (tree t, int include_virtuals_p)
4643 {
4644   tree result = size_zero_node;
4645   VEC(tree,gc) *vbases;
4646   tree binfo;
4647   tree base_binfo;
4648   tree offset;
4649   int i;
4650
4651   for (binfo = TYPE_BINFO (t), i = 0;
4652        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4653     {
4654       if (!include_virtuals_p
4655           && BINFO_VIRTUAL_P (base_binfo)
4656           && (!BINFO_PRIMARY_P (base_binfo)
4657               || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t)))
4658         continue;
4659
4660       offset = end_of_base (base_binfo);
4661       if (INT_CST_LT_UNSIGNED (result, offset))
4662         result = offset;
4663     }
4664
4665   /* G++ 3.2 did not check indirect virtual bases.  */
4666   if (abi_version_at_least (2) && include_virtuals_p)
4667     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4668          VEC_iterate (tree, vbases, i, base_binfo); i++)
4669       {
4670         offset = end_of_base (base_binfo);
4671         if (INT_CST_LT_UNSIGNED (result, offset))
4672           result = offset;
4673       }
4674
4675   return result;
4676 }
4677
4678 /* Warn about bases of T that are inaccessible because they are
4679    ambiguous.  For example:
4680
4681      struct S {};
4682      struct T : public S {};
4683      struct U : public S, public T {};
4684
4685    Here, `(S*) new U' is not allowed because there are two `S'
4686    subobjects of U.  */
4687
4688 static void
4689 warn_about_ambiguous_bases (tree t)
4690 {
4691   int i;
4692   VEC(tree,gc) *vbases;
4693   tree basetype;
4694   tree binfo;
4695   tree base_binfo;
4696
4697   /* If there are no repeated bases, nothing can be ambiguous.  */
4698   if (!CLASSTYPE_REPEATED_BASE_P (t))
4699     return;
4700
4701   /* Check direct bases.  */
4702   for (binfo = TYPE_BINFO (t), i = 0;
4703        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4704     {
4705       basetype = BINFO_TYPE (base_binfo);
4706
4707       if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
4708         warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
4709                  basetype, t);
4710     }
4711
4712   /* Check for ambiguous virtual bases.  */
4713   if (extra_warnings)
4714     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4715          VEC_iterate (tree, vbases, i, binfo); i++)
4716       {
4717         basetype = BINFO_TYPE (binfo);
4718
4719         if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
4720           warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due to ambiguity",
4721                    basetype, t);
4722       }
4723 }
4724
4725 /* Compare two INTEGER_CSTs K1 and K2.  */
4726
4727 static int
4728 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
4729 {
4730   return tree_int_cst_compare ((tree) k1, (tree) k2);
4731 }
4732
4733 /* Increase the size indicated in RLI to account for empty classes
4734    that are "off the end" of the class.  */
4735
4736 static void
4737 include_empty_classes (record_layout_info rli)
4738 {
4739   tree eoc;
4740   tree rli_size;
4741
4742   /* It might be the case that we grew the class to allocate a
4743      zero-sized base class.  That won't be reflected in RLI, yet,
4744      because we are willing to overlay multiple bases at the same
4745      offset.  However, now we need to make sure that RLI is big enough
4746      to reflect the entire class.  */
4747   eoc = end_of_class (rli->t,
4748                       CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
4749   rli_size = rli_size_unit_so_far (rli);
4750   if (TREE_CODE (rli_size) == INTEGER_CST
4751       && INT_CST_LT_UNSIGNED (rli_size, eoc))
4752     {
4753       if (!abi_version_at_least (2))
4754         /* In version 1 of the ABI, the size of a class that ends with
4755            a bitfield was not rounded up to a whole multiple of a
4756            byte.  Because rli_size_unit_so_far returns only the number
4757            of fully allocated bytes, any extra bits were not included
4758            in the size.  */
4759         rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
4760       else
4761         /* The size should have been rounded to a whole byte.  */
4762         gcc_assert (tree_int_cst_equal
4763                     (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT)));
4764       rli->bitpos
4765         = size_binop (PLUS_EXPR,
4766                       rli->bitpos,
4767                       size_binop (MULT_EXPR,
4768                                   convert (bitsizetype,
4769                                            size_binop (MINUS_EXPR,
4770                                                        eoc, rli_size)),
4771                                   bitsize_int (BITS_PER_UNIT)));
4772       normalize_rli (rli);
4773     }
4774 }
4775
4776 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T.  Calculate
4777    BINFO_OFFSETs for all of the base-classes.  Position the vtable
4778    pointer.  Accumulate declared virtual functions on VIRTUALS_P.  */
4779
4780 static void
4781 layout_class_type (tree t, tree *virtuals_p)
4782 {
4783   tree non_static_data_members;
4784   tree field;
4785   tree vptr;
4786   record_layout_info rli;
4787   /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4788      types that appear at that offset.  */
4789   splay_tree empty_base_offsets;
4790   /* True if the last field layed out was a bit-field.  */
4791   bool last_field_was_bitfield = false;
4792   /* The location at which the next field should be inserted.  */
4793   tree *next_field;
4794   /* T, as a base class.  */
4795   tree base_t;
4796
4797   /* Keep track of the first non-static data member.  */
4798   non_static_data_members = TYPE_FIELDS (t);
4799
4800   /* Start laying out the record.  */
4801   rli = start_record_layout (t);
4802
4803   /* Mark all the primary bases in the hierarchy.  */
4804   determine_primary_bases (t);
4805
4806   /* Create a pointer to our virtual function table.  */
4807   vptr = create_vtable_ptr (t, virtuals_p);
4808
4809   /* The vptr is always the first thing in the class.  */
4810   if (vptr)
4811     {
4812       TREE_CHAIN (vptr) = TYPE_FIELDS (t);
4813       TYPE_FIELDS (t) = vptr;
4814       next_field = &TREE_CHAIN (vptr);
4815       place_field (rli, vptr);
4816     }
4817   else
4818     next_field = &TYPE_FIELDS (t);
4819
4820   /* Build FIELD_DECLs for all of the non-virtual base-types.  */
4821   empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
4822                                        NULL, NULL);
4823   build_base_fields (rli, empty_base_offsets, next_field);
4824
4825   /* Layout the non-static data members.  */
4826   for (field = non_static_data_members; field; field = TREE_CHAIN (field))
4827     {
4828       tree type;
4829       tree padding;
4830
4831       /* We still pass things that aren't non-static data members to
4832          the back end, in case it wants to do something with them.  */
4833       if (TREE_CODE (field) != FIELD_DECL)
4834         {
4835           place_field (rli, field);
4836           /* If the static data member has incomplete type, keep track
4837              of it so that it can be completed later.  (The handling
4838              of pending statics in finish_record_layout is
4839              insufficient; consider:
4840
4841                struct S1;
4842                struct S2 { static S1 s1; };
4843
4844              At this point, finish_record_layout will be called, but
4845              S1 is still incomplete.)  */
4846           if (TREE_CODE (field) == VAR_DECL)
4847             {
4848               maybe_register_incomplete_var (field);
4849               /* The visibility of static data members is determined
4850                  at their point of declaration, not their point of
4851                  definition.  */
4852               determine_visibility (field);
4853             }
4854           continue;
4855         }
4856
4857       type = TREE_TYPE (field);
4858       if (type == error_mark_node)
4859         continue;
4860
4861       padding = NULL_TREE;
4862
4863       /* If this field is a bit-field whose width is greater than its
4864          type, then there are some special rules for allocating
4865          it.  */
4866       if (DECL_C_BIT_FIELD (field)
4867           && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
4868         {
4869           unsigned int itk;
4870           tree integer_type;
4871           bool was_unnamed_p = false;
4872           /* We must allocate the bits as if suitably aligned for the
4873              longest integer type that fits in this many bits.  type
4874              of the field.  Then, we are supposed to use the left over
4875              bits as additional padding.  */
4876           for (itk = itk_char; itk != itk_none; ++itk)
4877             if (INT_CST_LT (DECL_SIZE (field),
4878                             TYPE_SIZE (integer_types[itk])))
4879               break;
4880
4881           /* ITK now indicates a type that is too large for the
4882              field.  We have to back up by one to find the largest
4883              type that fits.  */
4884           integer_type = integer_types[itk - 1];
4885
4886           /* Figure out how much additional padding is required.  GCC
4887              3.2 always created a padding field, even if it had zero
4888              width.  */
4889           if (!abi_version_at_least (2)
4890               || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
4891             {
4892               if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
4893                 /* In a union, the padding field must have the full width
4894                    of the bit-field; all fields start at offset zero.  */
4895                 padding = DECL_SIZE (field);
4896               else
4897                 {
4898                   if (TREE_CODE (t) == UNION_TYPE)
4899                     warning (OPT_Wabi, "size assigned to %qT may not be "
4900                              "ABI-compliant and may change in a future "
4901                              "version of GCC",
4902                              t);
4903                   padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
4904                                         TYPE_SIZE (integer_type));
4905                 }
4906             }
4907 #ifdef PCC_BITFIELD_TYPE_MATTERS
4908           /* An unnamed bitfield does not normally affect the
4909              alignment of the containing class on a target where
4910              PCC_BITFIELD_TYPE_MATTERS.  But, the C++ ABI does not
4911              make any exceptions for unnamed bitfields when the
4912              bitfields are longer than their types.  Therefore, we
4913              temporarily give the field a name.  */
4914           if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
4915             {
4916               was_unnamed_p = true;
4917               DECL_NAME (field) = make_anon_name ();
4918             }
4919 #endif
4920           DECL_SIZE (field) = TYPE_SIZE (integer_type);
4921           DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
4922           DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
4923           layout_nonempty_base_or_field (rli, field, NULL_TREE,
4924                                          empty_base_offsets);
4925           if (was_unnamed_p)
4926             DECL_NAME (field) = NULL_TREE;
4927           /* Now that layout has been performed, set the size of the
4928              field to the size of its declared type; the rest of the
4929              field is effectively invisible.  */
4930           DECL_SIZE (field) = TYPE_SIZE (type);
4931           /* We must also reset the DECL_MODE of the field.  */
4932           if (abi_version_at_least (2))
4933             DECL_MODE (field) = TYPE_MODE (type);
4934           else if (warn_abi
4935                    && DECL_MODE (field) != TYPE_MODE (type))
4936             /* Versions of G++ before G++ 3.4 did not reset the
4937                DECL_MODE.  */
4938             warning (OPT_Wabi,
4939                      "the offset of %qD may not be ABI-compliant and may "
4940                      "change in a future version of GCC", field);
4941         }
4942       else
4943         layout_nonempty_base_or_field (rli, field, NULL_TREE,
4944                                        empty_base_offsets);
4945
4946       /* Remember the location of any empty classes in FIELD.  */
4947       if (abi_version_at_least (2))
4948         record_subobject_offsets (TREE_TYPE (field),
4949                                   byte_position(field),
4950                                   empty_base_offsets,
4951                                   /*is_data_member=*/true);
4952
4953       /* If a bit-field does not immediately follow another bit-field,
4954          and yet it starts in the middle of a byte, we have failed to
4955          comply with the ABI.  */
4956       if (warn_abi
4957           && DECL_C_BIT_FIELD (field)
4958           /* The TREE_NO_WARNING flag gets set by Objective-C when
4959              laying out an Objective-C class.  The ObjC ABI differs
4960              from the C++ ABI, and so we do not want a warning
4961              here.  */
4962           && !TREE_NO_WARNING (field)
4963           && !last_field_was_bitfield
4964           && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
4965                                          DECL_FIELD_BIT_OFFSET (field),
4966                                          bitsize_unit_node)))
4967         warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may "
4968                  "change in a future version of GCC", field);
4969
4970       /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4971          offset of the field.  */
4972       if (warn_abi
4973           && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
4974                                   byte_position (field))
4975           && contains_empty_class_p (TREE_TYPE (field)))
4976         warning (OPT_Wabi, "%q+D contains empty classes which may cause base "
4977                  "classes to be placed at different locations in a "
4978                  "future version of GCC", field);
4979
4980       /* The middle end uses the type of expressions to determine the
4981          possible range of expression values.  In order to optimize
4982          "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
4983          must be made aware of the width of "i", via its type.
4984
4985          Because C++ does not have integer types of arbitrary width,
4986          we must (for the purposes of the front end) convert from the
4987          type assigned here to the declared type of the bitfield
4988          whenever a bitfield expression is used as an rvalue.
4989          Similarly, when assigning a value to a bitfield, the value
4990          must be converted to the type given the bitfield here.  */
4991       if (DECL_C_BIT_FIELD (field))
4992         {
4993           unsigned HOST_WIDE_INT width;
4994           tree ftype = TREE_TYPE (field);
4995           width = tree_low_cst (DECL_SIZE (field), /*unsignedp=*/1);
4996           if (width != TYPE_PRECISION (ftype))
4997             {
4998               TREE_TYPE (field)
4999                 = c_build_bitfield_integer_type (width,
5000                                                  TYPE_UNSIGNED (ftype));
5001               TREE_TYPE (field)
5002                 = cp_build_qualified_type (TREE_TYPE (field),
5003                                            TYPE_QUALS (ftype));
5004             }
5005         }
5006
5007       /* If we needed additional padding after this field, add it
5008          now.  */
5009       if (padding)
5010         {
5011           tree padding_field;
5012
5013           padding_field = build_decl (input_location,
5014                                       FIELD_DECL,
5015                                       NULL_TREE,
5016                                       char_type_node);
5017           DECL_BIT_FIELD (padding_field) = 1;
5018           DECL_SIZE (padding_field) = padding;
5019           DECL_CONTEXT (padding_field) = t;
5020           DECL_ARTIFICIAL (padding_field) = 1;
5021           DECL_IGNORED_P (padding_field) = 1;
5022           layout_nonempty_base_or_field (rli, padding_field,
5023                                          NULL_TREE,
5024                                          empty_base_offsets);
5025         }
5026
5027       last_field_was_bitfield = DECL_C_BIT_FIELD (field);
5028     }
5029
5030   if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
5031     {
5032       /* Make sure that we are on a byte boundary so that the size of
5033          the class without virtual bases will always be a round number
5034          of bytes.  */
5035       rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT);
5036       normalize_rli (rli);
5037     }
5038
5039   /* G++ 3.2 does not allow virtual bases to be overlaid with tail
5040      padding.  */
5041   if (!abi_version_at_least (2))
5042     include_empty_classes(rli);
5043
5044   /* Delete all zero-width bit-fields from the list of fields.  Now
5045      that the type is laid out they are no longer important.  */
5046   remove_zero_width_bit_fields (t);
5047
5048   /* Create the version of T used for virtual bases.  We do not use
5049      make_class_type for this version; this is an artificial type.  For
5050      a POD type, we just reuse T.  */
5051   if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t))
5052     {
5053       base_t = make_node (TREE_CODE (t));
5054
5055       /* Set the size and alignment for the new type.  In G++ 3.2, all
5056          empty classes were considered to have size zero when used as
5057          base classes.  */
5058       if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
5059         {
5060           TYPE_SIZE (base_t) = bitsize_zero_node;
5061           TYPE_SIZE_UNIT (base_t) = size_zero_node;
5062           if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
5063             warning (OPT_Wabi,
5064                      "layout of classes derived from empty class %qT "
5065                      "may change in a future version of GCC",
5066                      t);
5067         }
5068       else
5069         {
5070           tree eoc;
5071
5072           /* If the ABI version is not at least two, and the last
5073              field was a bit-field, RLI may not be on a byte
5074              boundary.  In particular, rli_size_unit_so_far might
5075              indicate the last complete byte, while rli_size_so_far
5076              indicates the total number of bits used.  Therefore,
5077              rli_size_so_far, rather than rli_size_unit_so_far, is
5078              used to compute TYPE_SIZE_UNIT.  */
5079           eoc = end_of_class (t, /*include_virtuals_p=*/0);
5080           TYPE_SIZE_UNIT (base_t)
5081             = size_binop (MAX_EXPR,
5082                           convert (sizetype,
5083                                    size_binop (CEIL_DIV_EXPR,
5084                                                rli_size_so_far (rli),
5085                                                bitsize_int (BITS_PER_UNIT))),
5086                           eoc);
5087           TYPE_SIZE (base_t)
5088             = size_binop (MAX_EXPR,
5089                           rli_size_so_far (rli),
5090                           size_binop (MULT_EXPR,
5091                                       convert (bitsizetype, eoc),
5092                                       bitsize_int (BITS_PER_UNIT)));
5093         }
5094       TYPE_ALIGN (base_t) = rli->record_align;
5095       TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
5096
5097       /* Copy the fields from T.  */
5098       next_field = &TYPE_FIELDS (base_t);
5099       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
5100         if (TREE_CODE (field) == FIELD_DECL)
5101           {
5102             *next_field = build_decl (input_location,
5103                                       FIELD_DECL,
5104                                       DECL_NAME (field),
5105                                       TREE_TYPE (field));
5106             DECL_CONTEXT (*next_field) = base_t;
5107             DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
5108             DECL_FIELD_BIT_OFFSET (*next_field)
5109               = DECL_FIELD_BIT_OFFSET (field);
5110             DECL_SIZE (*next_field) = DECL_SIZE (field);
5111             DECL_MODE (*next_field) = DECL_MODE (field);
5112             next_field = &TREE_CHAIN (*next_field);
5113           }
5114
5115       /* Record the base version of the type.  */
5116       CLASSTYPE_AS_BASE (t) = base_t;
5117       TYPE_CONTEXT (base_t) = t;
5118     }
5119   else
5120     CLASSTYPE_AS_BASE (t) = t;
5121
5122   /* Every empty class contains an empty class.  */
5123   if (CLASSTYPE_EMPTY_P (t))
5124     CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
5125
5126   /* Set the TYPE_DECL for this type to contain the right
5127      value for DECL_OFFSET, so that we can use it as part
5128      of a COMPONENT_REF for multiple inheritance.  */
5129   layout_decl (TYPE_MAIN_DECL (t), 0);
5130
5131   /* Now fix up any virtual base class types that we left lying
5132      around.  We must get these done before we try to lay out the
5133      virtual function table.  As a side-effect, this will remove the
5134      base subobject fields.  */
5135   layout_virtual_bases (rli, empty_base_offsets);
5136
5137   /* Make sure that empty classes are reflected in RLI at this
5138      point.  */
5139   include_empty_classes(rli);
5140
5141   /* Make sure not to create any structures with zero size.  */
5142   if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
5143     place_field (rli,
5144                  build_decl (input_location,
5145                              FIELD_DECL, NULL_TREE, char_type_node));
5146
5147   /* Let the back end lay out the type.  */
5148   finish_record_layout (rli, /*free_p=*/true);
5149
5150   /* Warn about bases that can't be talked about due to ambiguity.  */
5151   warn_about_ambiguous_bases (t);
5152
5153   /* Now that we're done with layout, give the base fields the real types.  */
5154   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
5155     if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
5156       TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
5157
5158   /* Clean up.  */
5159   splay_tree_delete (empty_base_offsets);
5160
5161   if (CLASSTYPE_EMPTY_P (t)
5162       && tree_int_cst_lt (sizeof_biggest_empty_class,
5163                           TYPE_SIZE_UNIT (t)))
5164     sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
5165 }
5166
5167 /* Determine the "key method" for the class type indicated by TYPE,
5168    and set CLASSTYPE_KEY_METHOD accordingly.  */
5169
5170 void
5171 determine_key_method (tree type)
5172 {
5173   tree method;
5174
5175   if (TYPE_FOR_JAVA (type)
5176       || processing_template_decl
5177       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
5178       || CLASSTYPE_INTERFACE_KNOWN (type))
5179     return;
5180
5181   /* The key method is the first non-pure virtual function that is not
5182      inline at the point of class definition.  On some targets the
5183      key function may not be inline; those targets should not call
5184      this function until the end of the translation unit.  */
5185   for (method = TYPE_METHODS (type); method != NULL_TREE;
5186        method = TREE_CHAIN (method))
5187     if (DECL_VINDEX (method) != NULL_TREE
5188         && ! DECL_DECLARED_INLINE_P (method)
5189         && ! DECL_PURE_VIRTUAL_P (method))
5190       {
5191         CLASSTYPE_KEY_METHOD (type) = method;
5192         break;
5193       }
5194
5195   return;
5196 }
5197
5198 /* Perform processing required when the definition of T (a class type)
5199    is complete.  */
5200
5201 void
5202 finish_struct_1 (tree t)
5203 {
5204   tree x;
5205   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
5206   tree virtuals = NULL_TREE;
5207   int n_fields = 0;
5208
5209   if (COMPLETE_TYPE_P (t))
5210     {
5211       gcc_assert (MAYBE_CLASS_TYPE_P (t));
5212       error ("redefinition of %q#T", t);
5213       popclass ();
5214       return;
5215     }
5216
5217   /* If this type was previously laid out as a forward reference,
5218      make sure we lay it out again.  */
5219   TYPE_SIZE (t) = NULL_TREE;
5220   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5221
5222   fixup_inline_methods (t);
5223
5224   /* Make assumptions about the class; we'll reset the flags if
5225      necessary.  */
5226   CLASSTYPE_EMPTY_P (t) = 1;
5227   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5228   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5229
5230   /* Do end-of-class semantic processing: checking the validity of the
5231      bases and members and add implicitly generated methods.  */
5232   check_bases_and_members (t);
5233
5234   /* Find the key method.  */
5235   if (TYPE_CONTAINS_VPTR_P (t))
5236     {
5237       /* The Itanium C++ ABI permits the key method to be chosen when
5238          the class is defined -- even though the key method so
5239          selected may later turn out to be an inline function.  On
5240          some systems (such as ARM Symbian OS) the key method cannot
5241          be determined until the end of the translation unit.  On such
5242          systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
5243          will cause the class to be added to KEYED_CLASSES.  Then, in
5244          finish_file we will determine the key method.  */
5245       if (targetm.cxx.key_method_may_be_inline ())
5246         determine_key_method (t);
5247
5248       /* If a polymorphic class has no key method, we may emit the vtable
5249          in every translation unit where the class definition appears.  */
5250       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5251         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5252     }
5253
5254   /* Layout the class itself.  */
5255   layout_class_type (t, &virtuals);
5256   if (CLASSTYPE_AS_BASE (t) != t)
5257     /* We use the base type for trivial assignments, and hence it
5258        needs a mode.  */
5259     compute_record_mode (CLASSTYPE_AS_BASE (t));
5260
5261   virtuals = modify_all_vtables (t, nreverse (virtuals));
5262
5263   /* If necessary, create the primary vtable for this class.  */
5264   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5265     {
5266       /* We must enter these virtuals into the table.  */
5267       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5268         build_primary_vtable (NULL_TREE, t);
5269       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5270         /* Here we know enough to change the type of our virtual
5271            function table, but we will wait until later this function.  */
5272         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5273     }
5274
5275   if (TYPE_CONTAINS_VPTR_P (t))
5276     {
5277       int vindex;
5278       tree fn;
5279
5280       if (BINFO_VTABLE (TYPE_BINFO (t)))
5281         gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
5282       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5283         gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
5284
5285       /* Add entries for virtual functions introduced by this class.  */
5286       BINFO_VIRTUALS (TYPE_BINFO (t))
5287         = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
5288
5289       /* Set DECL_VINDEX for all functions declared in this class.  */
5290       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5291            fn;
5292            fn = TREE_CHAIN (fn),
5293              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5294                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5295         {
5296           tree fndecl = BV_FN (fn);
5297
5298           if (DECL_THUNK_P (fndecl))
5299             /* A thunk. We should never be calling this entry directly
5300                from this vtable -- we'd use the entry for the non
5301                thunk base function.  */
5302             DECL_VINDEX (fndecl) = NULL_TREE;
5303           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5304             DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
5305         }
5306     }
5307
5308   finish_struct_bits (t);
5309
5310   /* Complete the rtl for any static member objects of the type we're
5311      working on.  */
5312   for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5313     if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5314         && TREE_TYPE (x) != error_mark_node
5315         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5316       DECL_MODE (x) = TYPE_MODE (t);
5317
5318   /* Done with FIELDS...now decide whether to sort these for
5319      faster lookups later.
5320
5321      We use a small number because most searches fail (succeeding
5322      ultimately as the search bores through the inheritance
5323      hierarchy), and we want this failure to occur quickly.  */
5324
5325   n_fields = count_fields (TYPE_FIELDS (t));
5326   if (n_fields > 7)
5327     {
5328       struct sorted_fields_type *field_vec = GGC_NEWVAR
5329          (struct sorted_fields_type,
5330           sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
5331       field_vec->len = n_fields;
5332       add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5333       qsort (field_vec->elts, n_fields, sizeof (tree),
5334              field_decl_cmp);
5335       if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5336         retrofit_lang_decl (TYPE_MAIN_DECL (t));
5337       DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5338     }
5339
5340   /* Complain if one of the field types requires lower visibility.  */
5341   constrain_class_visibility (t);
5342
5343   /* Make the rtl for any new vtables we have created, and unmark
5344      the base types we marked.  */
5345   finish_vtbls (t);
5346
5347   /* Build the VTT for T.  */
5348   build_vtt (t);
5349
5350   /* This warning does not make sense for Java classes, since they
5351      cannot have destructors.  */
5352   if (!TYPE_FOR_JAVA (t) && warn_nonvdtor && TYPE_POLYMORPHIC_P (t))
5353     {
5354       tree dtor;
5355
5356       dtor = CLASSTYPE_DESTRUCTORS (t);
5357       if (/* An implicitly declared destructor is always public.  And,
5358              if it were virtual, we would have created it by now.  */
5359           !dtor
5360           || (!DECL_VINDEX (dtor)
5361               && (/* public non-virtual */
5362                   (!TREE_PRIVATE (dtor) && !TREE_PROTECTED (dtor))
5363                    || (/* non-public non-virtual with friends */
5364                        (TREE_PRIVATE (dtor) || TREE_PROTECTED (dtor))
5365                         && (CLASSTYPE_FRIEND_CLASSES (t)
5366                         || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))))))
5367         warning (OPT_Wnon_virtual_dtor,
5368                  "%q#T has virtual functions and accessible"
5369                  " non-virtual destructor", t);
5370     }
5371
5372   complete_vars (t);
5373
5374   if (warn_overloaded_virtual)
5375     warn_hidden (t);
5376
5377   /* Class layout, assignment of virtual table slots, etc., is now
5378      complete.  Give the back end a chance to tweak the visibility of
5379      the class or perform any other required target modifications.  */
5380   targetm.cxx.adjust_class_at_definition (t);
5381
5382   maybe_suppress_debug_info (t);
5383
5384   dump_class_hierarchy (t);
5385
5386   /* Finish debugging output for this type.  */
5387   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5388 }
5389
5390 /* When T was built up, the member declarations were added in reverse
5391    order.  Rearrange them to declaration order.  */
5392
5393 void
5394 unreverse_member_declarations (tree t)
5395 {
5396   tree next;
5397   tree prev;
5398   tree x;
5399
5400   /* The following lists are all in reverse order.  Put them in
5401      declaration order now.  */
5402   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5403   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5404
5405   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5406      reverse order, so we can't just use nreverse.  */
5407   prev = NULL_TREE;
5408   for (x = TYPE_FIELDS (t);
5409        x && TREE_CODE (x) != TYPE_DECL;
5410        x = next)
5411     {
5412       next = TREE_CHAIN (x);
5413       TREE_CHAIN (x) = prev;
5414       prev = x;
5415     }
5416   if (prev)
5417     {
5418       TREE_CHAIN (TYPE_FIELDS (t)) = x;
5419       if (prev)
5420         TYPE_FIELDS (t) = prev;
5421     }
5422 }
5423
5424 tree
5425 finish_struct (tree t, tree attributes)
5426 {
5427   location_t saved_loc = input_location;
5428
5429   /* Now that we've got all the field declarations, reverse everything
5430      as necessary.  */
5431   unreverse_member_declarations (t);
5432
5433   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5434
5435   /* Nadger the current location so that diagnostics point to the start of
5436      the struct, not the end.  */
5437   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5438
5439   if (processing_template_decl)
5440     {
5441       tree x;
5442
5443       finish_struct_methods (t);
5444       TYPE_SIZE (t) = bitsize_zero_node;
5445       TYPE_SIZE_UNIT (t) = size_zero_node;
5446
5447       /* We need to emit an error message if this type was used as a parameter
5448          and it is an abstract type, even if it is a template. We construct
5449          a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5450          account and we call complete_vars with this type, which will check
5451          the PARM_DECLS. Note that while the type is being defined,
5452          CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5453          (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it.  */
5454       CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5455       for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
5456         if (DECL_PURE_VIRTUAL_P (x))
5457           VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
5458       complete_vars (t);
5459     }
5460   else
5461     finish_struct_1 (t);
5462
5463   input_location = saved_loc;
5464
5465   TYPE_BEING_DEFINED (t) = 0;
5466
5467   if (current_class_type)
5468     popclass ();
5469   else
5470     error ("trying to finish struct, but kicked out due to previous parse errors");
5471
5472   if (processing_template_decl && at_function_scope_p ())
5473     add_stmt (build_min (TAG_DEFN, t));
5474
5475   return t;
5476 }
5477 \f
5478 /* Return the dynamic type of INSTANCE, if known.
5479    Used to determine whether the virtual function table is needed
5480    or not.
5481
5482    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5483    of our knowledge of its type.  *NONNULL should be initialized
5484    before this function is called.  */
5485
5486 static tree
5487 fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
5488 {
5489 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
5490
5491   switch (TREE_CODE (instance))
5492     {
5493     case INDIRECT_REF:
5494       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5495         return NULL_TREE;
5496       else
5497         return RECUR (TREE_OPERAND (instance, 0));
5498
5499     case CALL_EXPR:
5500       /* This is a call to a constructor, hence it's never zero.  */
5501       if (TREE_HAS_CONSTRUCTOR (instance))
5502         {
5503           if (nonnull)
5504             *nonnull = 1;
5505           return TREE_TYPE (instance);
5506         }
5507       return NULL_TREE;
5508
5509     case SAVE_EXPR:
5510       /* This is a call to a constructor, hence it's never zero.  */
5511       if (TREE_HAS_CONSTRUCTOR (instance))
5512         {
5513           if (nonnull)
5514             *nonnull = 1;
5515           return TREE_TYPE (instance);
5516         }
5517       return RECUR (TREE_OPERAND (instance, 0));
5518
5519     case POINTER_PLUS_EXPR:
5520     case PLUS_EXPR:
5521     case MINUS_EXPR:
5522       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5523         return RECUR (TREE_OPERAND (instance, 0));
5524       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5525         /* Propagate nonnull.  */
5526         return RECUR (TREE_OPERAND (instance, 0));
5527
5528       return NULL_TREE;
5529
5530     CASE_CONVERT:
5531       return RECUR (TREE_OPERAND (instance, 0));
5532
5533     case ADDR_EXPR:
5534       instance = TREE_OPERAND (instance, 0);
5535       if (nonnull)
5536         {
5537           /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5538              with a real object -- given &p->f, p can still be null.  */
5539           tree t = get_base_address (instance);
5540           /* ??? Probably should check DECL_WEAK here.  */
5541           if (t && DECL_P (t))
5542             *nonnull = 1;
5543         }
5544       return RECUR (instance);
5545
5546     case COMPONENT_REF:
5547       /* If this component is really a base class reference, then the field
5548          itself isn't definitive.  */
5549       if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5550         return RECUR (TREE_OPERAND (instance, 0));
5551       return RECUR (TREE_OPERAND (instance, 1));
5552
5553     case VAR_DECL:
5554     case FIELD_DECL:
5555       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5556           && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance))))
5557         {
5558           if (nonnull)
5559             *nonnull = 1;
5560           return TREE_TYPE (TREE_TYPE (instance));
5561         }
5562       /* fall through...  */
5563     case TARGET_EXPR:
5564     case PARM_DECL:
5565     case RESULT_DECL:
5566       if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance)))
5567         {
5568           if (nonnull)
5569             *nonnull = 1;
5570           return TREE_TYPE (instance);
5571         }
5572       else if (instance == current_class_ptr)
5573         {
5574           if (nonnull)
5575             *nonnull = 1;
5576
5577           /* if we're in a ctor or dtor, we know our type.  */
5578           if (DECL_LANG_SPECIFIC (current_function_decl)
5579               && (DECL_CONSTRUCTOR_P (current_function_decl)
5580                   || DECL_DESTRUCTOR_P (current_function_decl)))
5581             {
5582               if (cdtorp)
5583                 *cdtorp = 1;
5584               return TREE_TYPE (TREE_TYPE (instance));
5585             }
5586         }
5587       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5588         {
5589           /* We only need one hash table because it is always left empty.  */
5590           static htab_t ht;
5591           if (!ht)
5592             ht = htab_create (37,
5593                               htab_hash_pointer,
5594                               htab_eq_pointer,
5595                               /*htab_del=*/NULL);
5596
5597           /* Reference variables should be references to objects.  */
5598           if (nonnull)
5599             *nonnull = 1;
5600
5601           /* Enter the INSTANCE in a table to prevent recursion; a
5602              variable's initializer may refer to the variable
5603              itself.  */
5604           if (TREE_CODE (instance) == VAR_DECL
5605               && DECL_INITIAL (instance)
5606               && !htab_find (ht, instance))
5607             {
5608               tree type;
5609               void **slot;
5610
5611               slot = htab_find_slot (ht, instance, INSERT);
5612               *slot = instance;
5613               type = RECUR (DECL_INITIAL (instance));
5614               htab_remove_elt (ht, instance);
5615
5616               return type;
5617             }
5618         }
5619       return NULL_TREE;
5620
5621     default:
5622       return NULL_TREE;
5623     }
5624 #undef RECUR
5625 }
5626
5627 /* Return nonzero if the dynamic type of INSTANCE is known, and
5628    equivalent to the static type.  We also handle the case where
5629    INSTANCE is really a pointer. Return negative if this is a
5630    ctor/dtor. There the dynamic type is known, but this might not be
5631    the most derived base of the original object, and hence virtual
5632    bases may not be layed out according to this type.
5633
5634    Used to determine whether the virtual function table is needed
5635    or not.
5636
5637    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5638    of our knowledge of its type.  *NONNULL should be initialized
5639    before this function is called.  */
5640
5641 int
5642 resolves_to_fixed_type_p (tree instance, int* nonnull)
5643 {
5644   tree t = TREE_TYPE (instance);
5645   int cdtorp = 0;
5646   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5647   if (fixed == NULL_TREE)
5648     return 0;
5649   if (POINTER_TYPE_P (t))
5650     t = TREE_TYPE (t);
5651   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5652     return 0;
5653   return cdtorp ? -1 : 1;
5654 }
5655
5656 \f
5657 void
5658 init_class_processing (void)
5659 {
5660   current_class_depth = 0;
5661   current_class_stack_size = 10;
5662   current_class_stack
5663     = XNEWVEC (struct class_stack_node, current_class_stack_size);
5664   local_classes = VEC_alloc (tree, gc, 8);
5665   sizeof_biggest_empty_class = size_zero_node;
5666
5667   ridpointers[(int) RID_PUBLIC] = access_public_node;
5668   ridpointers[(int) RID_PRIVATE] = access_private_node;
5669   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5670 }
5671
5672 /* Restore the cached PREVIOUS_CLASS_LEVEL.  */
5673
5674 static void
5675 restore_class_cache (void)
5676 {
5677   tree type;
5678
5679   /* We are re-entering the same class we just left, so we don't
5680      have to search the whole inheritance matrix to find all the
5681      decls to bind again.  Instead, we install the cached
5682      class_shadowed list and walk through it binding names.  */
5683   push_binding_level (previous_class_level);
5684   class_binding_level = previous_class_level;
5685   /* Restore IDENTIFIER_TYPE_VALUE.  */
5686   for (type = class_binding_level->type_shadowed;
5687        type;
5688        type = TREE_CHAIN (type))
5689     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5690 }
5691
5692 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5693    appropriate for TYPE.
5694
5695    So that we may avoid calls to lookup_name, we cache the _TYPE
5696    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5697
5698    For multiple inheritance, we perform a two-pass depth-first search
5699    of the type lattice.  */
5700
5701 void
5702 pushclass (tree type)
5703 {
5704   class_stack_node_t csn;
5705
5706   type = TYPE_MAIN_VARIANT (type);
5707
5708   /* Make sure there is enough room for the new entry on the stack.  */
5709   if (current_class_depth + 1 >= current_class_stack_size)
5710     {
5711       current_class_stack_size *= 2;
5712       current_class_stack
5713         = XRESIZEVEC (struct class_stack_node, current_class_stack,
5714                       current_class_stack_size);
5715     }
5716
5717   /* Insert a new entry on the class stack.  */
5718   csn = current_class_stack + current_class_depth;
5719   csn->name = current_class_name;
5720   csn->type = current_class_type;
5721   csn->access = current_access_specifier;
5722   csn->names_used = 0;
5723   csn->hidden = 0;
5724   current_class_depth++;
5725
5726   /* Now set up the new type.  */
5727   current_class_name = TYPE_NAME (type);
5728   if (TREE_CODE (current_class_name) == TYPE_DECL)
5729     current_class_name = DECL_NAME (current_class_name);
5730   current_class_type = type;
5731
5732   /* By default, things in classes are private, while things in
5733      structures or unions are public.  */
5734   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5735                               ? access_private_node
5736                               : access_public_node);
5737
5738   if (previous_class_level
5739       && type != previous_class_level->this_entity
5740       && current_class_depth == 1)
5741     {
5742       /* Forcibly remove any old class remnants.  */
5743       invalidate_class_lookup_cache ();
5744     }
5745
5746   if (!previous_class_level
5747       || type != previous_class_level->this_entity
5748       || current_class_depth > 1)
5749     pushlevel_class ();
5750   else
5751     restore_class_cache ();
5752 }
5753
5754 /* When we exit a toplevel class scope, we save its binding level so
5755    that we can restore it quickly.  Here, we've entered some other
5756    class, so we must invalidate our cache.  */
5757
5758 void
5759 invalidate_class_lookup_cache (void)
5760 {
5761   previous_class_level = NULL;
5762 }
5763
5764 /* Get out of the current class scope. If we were in a class scope
5765    previously, that is the one popped to.  */
5766
5767 void
5768 popclass (void)
5769 {
5770   poplevel_class ();
5771
5772   current_class_depth--;
5773   current_class_name = current_class_stack[current_class_depth].name;
5774   current_class_type = current_class_stack[current_class_depth].type;
5775   current_access_specifier = current_class_stack[current_class_depth].access;
5776   if (current_class_stack[current_class_depth].names_used)
5777     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5778 }
5779
5780 /* Mark the top of the class stack as hidden.  */
5781
5782 void
5783 push_class_stack (void)
5784 {
5785   if (current_class_depth)
5786     ++current_class_stack[current_class_depth - 1].hidden;
5787 }
5788
5789 /* Mark the top of the class stack as un-hidden.  */
5790
5791 void
5792 pop_class_stack (void)
5793 {
5794   if (current_class_depth)
5795     --current_class_stack[current_class_depth - 1].hidden;
5796 }
5797
5798 /* Returns 1 if the class type currently being defined is either T or
5799    a nested type of T.  */
5800
5801 bool
5802 currently_open_class (tree t)
5803 {
5804   int i;
5805
5806   if (!CLASS_TYPE_P (t))
5807     return false;
5808
5809   /* We start looking from 1 because entry 0 is from global scope,
5810      and has no type.  */
5811   for (i = current_class_depth; i > 0; --i)
5812     {
5813       tree c;
5814       if (i == current_class_depth)
5815         c = current_class_type;
5816       else
5817         {
5818           if (current_class_stack[i].hidden)
5819             break;
5820           c = current_class_stack[i].type;
5821         }
5822       if (!c)
5823         continue;
5824       if (same_type_p (c, t))
5825         return true;
5826     }
5827   return false;
5828 }
5829
5830 /* If either current_class_type or one of its enclosing classes are derived
5831    from T, return the appropriate type.  Used to determine how we found
5832    something via unqualified lookup.  */
5833
5834 tree
5835 currently_open_derived_class (tree t)
5836 {
5837   int i;
5838
5839   /* The bases of a dependent type are unknown.  */
5840   if (dependent_type_p (t))
5841     return NULL_TREE;
5842
5843   if (!current_class_type)
5844     return NULL_TREE;
5845
5846   if (DERIVED_FROM_P (t, current_class_type))
5847     return current_class_type;
5848
5849   for (i = current_class_depth - 1; i > 0; --i)
5850     {
5851       if (current_class_stack[i].hidden)
5852         break;
5853       if (DERIVED_FROM_P (t, current_class_stack[i].type))
5854         return current_class_stack[i].type;
5855     }
5856
5857   return NULL_TREE;
5858 }
5859
5860 /* When entering a class scope, all enclosing class scopes' names with
5861    static meaning (static variables, static functions, types and
5862    enumerators) have to be visible.  This recursive function calls
5863    pushclass for all enclosing class contexts until global or a local
5864    scope is reached.  TYPE is the enclosed class.  */
5865
5866 void
5867 push_nested_class (tree type)
5868 {
5869   /* A namespace might be passed in error cases, like A::B:C.  */
5870   if (type == NULL_TREE
5871       || !CLASS_TYPE_P (type))
5872     return;
5873
5874   push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type)));
5875
5876   pushclass (type);
5877 }
5878
5879 /* Undoes a push_nested_class call.  */
5880
5881 void
5882 pop_nested_class (void)
5883 {
5884   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5885
5886   popclass ();
5887   if (context && CLASS_TYPE_P (context))
5888     pop_nested_class ();
5889 }
5890
5891 /* Returns the number of extern "LANG" blocks we are nested within.  */
5892
5893 int
5894 current_lang_depth (void)
5895 {
5896   return VEC_length (tree, current_lang_base);
5897 }
5898
5899 /* Set global variables CURRENT_LANG_NAME to appropriate value
5900    so that behavior of name-mangling machinery is correct.  */
5901
5902 void
5903 push_lang_context (tree name)
5904 {
5905   VEC_safe_push (tree, gc, current_lang_base, current_lang_name);
5906
5907   if (name == lang_name_cplusplus)
5908     {
5909       current_lang_name = name;
5910     }
5911   else if (name == lang_name_java)
5912     {
5913       current_lang_name = name;
5914       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5915          (See record_builtin_java_type in decl.c.)  However, that causes
5916          incorrect debug entries if these types are actually used.
5917          So we re-enable debug output after extern "Java".  */
5918       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5919       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5920       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5921       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5922       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5923       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5924       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5925       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5926     }
5927   else if (name == lang_name_c)
5928     {
5929       current_lang_name = name;
5930     }
5931   else
5932     error ("language string %<\"%E\"%> not recognized", name);
5933 }
5934
5935 /* Get out of the current language scope.  */
5936
5937 void
5938 pop_lang_context (void)
5939 {
5940   current_lang_name = VEC_pop (tree, current_lang_base);
5941 }
5942 \f
5943 /* Type instantiation routines.  */
5944
5945 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5946    matches the TARGET_TYPE.  If there is no satisfactory match, return
5947    error_mark_node, and issue an error & warning messages under
5948    control of FLAGS.  Permit pointers to member function if FLAGS
5949    permits.  If TEMPLATE_ONLY, the name of the overloaded function was
5950    a template-id, and EXPLICIT_TARGS are the explicitly provided
5951    template arguments.
5952
5953    If OVERLOAD is for one or more member functions, then ACCESS_PATH
5954    is the base path used to reference those member functions.  If
5955    TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
5956    resolved to a member function, access checks will be performed and
5957    errors issued if appropriate.  */
5958
5959 static tree
5960 resolve_address_of_overloaded_function (tree target_type,
5961                                         tree overload,
5962                                         tsubst_flags_t flags,
5963                                         bool template_only,
5964                                         tree explicit_targs,
5965                                         tree access_path)
5966 {
5967   /* Here's what the standard says:
5968
5969        [over.over]
5970
5971        If the name is a function template, template argument deduction
5972        is done, and if the argument deduction succeeds, the deduced
5973        arguments are used to generate a single template function, which
5974        is added to the set of overloaded functions considered.
5975
5976        Non-member functions and static member functions match targets of
5977        type "pointer-to-function" or "reference-to-function."  Nonstatic
5978        member functions match targets of type "pointer-to-member
5979        function;" the function type of the pointer to member is used to
5980        select the member function from the set of overloaded member
5981        functions.  If a nonstatic member function is selected, the
5982        reference to the overloaded function name is required to have the
5983        form of a pointer to member as described in 5.3.1.
5984
5985        If more than one function is selected, any template functions in
5986        the set are eliminated if the set also contains a non-template
5987        function, and any given template function is eliminated if the
5988        set contains a second template function that is more specialized
5989        than the first according to the partial ordering rules 14.5.5.2.
5990        After such eliminations, if any, there shall remain exactly one
5991        selected function.  */
5992
5993   int is_ptrmem = 0;
5994   int is_reference = 0;
5995   /* We store the matches in a TREE_LIST rooted here.  The functions
5996      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5997      interoperability with most_specialized_instantiation.  */
5998   tree matches = NULL_TREE;
5999   tree fn;
6000
6001   /* By the time we get here, we should be seeing only real
6002      pointer-to-member types, not the internal POINTER_TYPE to
6003      METHOD_TYPE representation.  */
6004   gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
6005               || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
6006
6007   gcc_assert (is_overloaded_fn (overload));
6008
6009   /* Check that the TARGET_TYPE is reasonable.  */
6010   if (TYPE_PTRFN_P (target_type))
6011     /* This is OK.  */;
6012   else if (TYPE_PTRMEMFUNC_P (target_type))
6013     /* This is OK, too.  */
6014     is_ptrmem = 1;
6015   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
6016     {
6017       /* This is OK, too.  This comes from a conversion to reference
6018          type.  */
6019       target_type = build_reference_type (target_type);
6020       is_reference = 1;
6021     }
6022   else
6023     {
6024       if (flags & tf_error)
6025         error ("cannot resolve overloaded function %qD based on"
6026                " conversion to type %qT",
6027                DECL_NAME (OVL_FUNCTION (overload)), target_type);
6028       return error_mark_node;
6029     }
6030
6031   /* If we can find a non-template function that matches, we can just
6032      use it.  There's no point in generating template instantiations
6033      if we're just going to throw them out anyhow.  But, of course, we
6034      can only do this when we don't *need* a template function.  */
6035   if (!template_only)
6036     {
6037       tree fns;
6038
6039       for (fns = overload; fns; fns = OVL_NEXT (fns))
6040         {
6041           tree fn = OVL_CURRENT (fns);
6042           tree fntype;
6043
6044           if (TREE_CODE (fn) == TEMPLATE_DECL)
6045             /* We're not looking for templates just yet.  */
6046             continue;
6047
6048           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6049               != is_ptrmem)
6050             /* We're looking for a non-static member, and this isn't
6051                one, or vice versa.  */
6052             continue;
6053
6054           /* Ignore functions which haven't been explicitly
6055              declared.  */
6056           if (DECL_ANTICIPATED (fn))
6057             continue;
6058
6059           /* See if there's a match.  */
6060           fntype = TREE_TYPE (fn);
6061           if (is_ptrmem)
6062             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
6063           else if (!is_reference)
6064             fntype = build_pointer_type (fntype);
6065
6066           if (can_convert_arg (target_type, fntype, fn, LOOKUP_NORMAL))
6067             matches = tree_cons (fn, NULL_TREE, matches);
6068         }
6069     }
6070
6071   /* Now, if we've already got a match (or matches), there's no need
6072      to proceed to the template functions.  But, if we don't have a
6073      match we need to look at them, too.  */
6074   if (!matches)
6075     {
6076       tree target_fn_type;
6077       tree target_arg_types;
6078       tree target_ret_type;
6079       tree fns;
6080       tree *args;
6081       unsigned int nargs, ia;
6082       tree arg;
6083
6084       if (is_ptrmem)
6085         target_fn_type
6086           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
6087       else
6088         target_fn_type = TREE_TYPE (target_type);
6089       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
6090       target_ret_type = TREE_TYPE (target_fn_type);
6091
6092       /* Never do unification on the 'this' parameter.  */
6093       if (TREE_CODE (target_fn_type) == METHOD_TYPE)
6094         target_arg_types = TREE_CHAIN (target_arg_types);
6095
6096       nargs = list_length (target_arg_types);
6097       args = XALLOCAVEC (tree, nargs);
6098       for (arg = target_arg_types, ia = 0;
6099            arg != NULL_TREE && arg != void_list_node;
6100            arg = TREE_CHAIN (arg), ++ia)
6101         args[ia] = TREE_VALUE (arg);
6102       nargs = ia;
6103
6104       for (fns = overload; fns; fns = OVL_NEXT (fns))
6105         {
6106           tree fn = OVL_CURRENT (fns);
6107           tree instantiation;
6108           tree instantiation_type;
6109           tree targs;
6110
6111           if (TREE_CODE (fn) != TEMPLATE_DECL)
6112             /* We're only looking for templates.  */
6113             continue;
6114
6115           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6116               != is_ptrmem)
6117             /* We're not looking for a non-static member, and this is
6118                one, or vice versa.  */
6119             continue;
6120
6121           /* Try to do argument deduction.  */
6122           targs = make_tree_vec (DECL_NTPARMS (fn));
6123           if (fn_type_unification (fn, explicit_targs, targs, args, nargs,
6124                                    target_ret_type, DEDUCE_EXACT,
6125                                    LOOKUP_NORMAL))
6126             /* Argument deduction failed.  */
6127             continue;
6128
6129           /* Instantiate the template.  */
6130           instantiation = instantiate_template (fn, targs, flags);
6131           if (instantiation == error_mark_node)
6132             /* Instantiation failed.  */
6133             continue;
6134
6135           /* See if there's a match.  */
6136           instantiation_type = TREE_TYPE (instantiation);
6137           if (is_ptrmem)
6138             instantiation_type =
6139               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
6140           else if (!is_reference)
6141             instantiation_type = build_pointer_type (instantiation_type);
6142           if (can_convert_arg (target_type, instantiation_type, instantiation,
6143                                LOOKUP_NORMAL))
6144             matches = tree_cons (instantiation, fn, matches);
6145         }
6146
6147       /* Now, remove all but the most specialized of the matches.  */
6148       if (matches)
6149         {
6150           tree match = most_specialized_instantiation (matches);
6151
6152           if (match != error_mark_node)
6153             matches = tree_cons (TREE_PURPOSE (match),
6154                                  NULL_TREE,
6155                                  NULL_TREE);
6156         }
6157     }
6158
6159   /* Now we should have exactly one function in MATCHES.  */
6160   if (matches == NULL_TREE)
6161     {
6162       /* There were *no* matches.  */
6163       if (flags & tf_error)
6164         {
6165           error ("no matches converting function %qD to type %q#T",
6166                  DECL_NAME (OVL_CURRENT (overload)),
6167                  target_type);
6168
6169           /* print_candidates expects a chain with the functions in
6170              TREE_VALUE slots, so we cons one up here (we're losing anyway,
6171              so why be clever?).  */
6172           for (; overload; overload = OVL_NEXT (overload))
6173             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
6174                                  matches);
6175
6176           print_candidates (matches);
6177         }
6178       return error_mark_node;
6179     }
6180   else if (TREE_CHAIN (matches))
6181     {
6182       /* There were too many matches.  First check if they're all
6183          the same function.  */
6184       tree match;
6185
6186       fn = TREE_PURPOSE (matches);
6187       for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match))
6188         if (!decls_match (fn, TREE_PURPOSE (matches)))
6189           break;
6190
6191       if (match)
6192         {
6193           if (flags & tf_error)
6194             {
6195               error ("converting overloaded function %qD to type %q#T is ambiguous",
6196                      DECL_NAME (OVL_FUNCTION (overload)),
6197                      target_type);
6198
6199               /* Since print_candidates expects the functions in the
6200                  TREE_VALUE slot, we flip them here.  */
6201               for (match = matches; match; match = TREE_CHAIN (match))
6202                 TREE_VALUE (match) = TREE_PURPOSE (match);
6203
6204               print_candidates (matches);
6205             }
6206
6207           return error_mark_node;
6208         }
6209     }
6210
6211   /* Good, exactly one match.  Now, convert it to the correct type.  */
6212   fn = TREE_PURPOSE (matches);
6213
6214   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
6215       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
6216     {
6217       static int explained;
6218
6219       if (!(flags & tf_error))
6220         return error_mark_node;
6221
6222       permerror (input_location, "assuming pointer to member %qD", fn);
6223       if (!explained)
6224         {
6225           inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
6226           explained = 1;
6227         }
6228     }
6229
6230   /* If we're doing overload resolution purely for the purpose of
6231      determining conversion sequences, we should not consider the
6232      function used.  If this conversion sequence is selected, the
6233      function will be marked as used at this point.  */
6234   if (!(flags & tf_conv))
6235     {
6236       /* Make =delete work with SFINAE.  */
6237       if (DECL_DELETED_FN (fn) && !(flags & tf_error))
6238         return error_mark_node;
6239
6240       mark_used (fn);
6241     }
6242
6243   /* We could not check access to member functions when this
6244      expression was originally created since we did not know at that
6245      time to which function the expression referred.  */
6246   if (!(flags & tf_no_access_control)
6247       && DECL_FUNCTION_MEMBER_P (fn))
6248     {
6249       gcc_assert (access_path);
6250       perform_or_defer_access_check (access_path, fn, fn);
6251     }
6252
6253   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
6254     return cp_build_unary_op (ADDR_EXPR, fn, 0, flags);
6255   else
6256     {
6257       /* The target must be a REFERENCE_TYPE.  Above, cp_build_unary_op
6258          will mark the function as addressed, but here we must do it
6259          explicitly.  */
6260       cxx_mark_addressable (fn);
6261
6262       return fn;
6263     }
6264 }
6265
6266 /* This function will instantiate the type of the expression given in
6267    RHS to match the type of LHSTYPE.  If errors exist, then return
6268    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
6269    we complain on errors.  If we are not complaining, never modify rhs,
6270    as overload resolution wants to try many possible instantiations, in
6271    the hope that at least one will work.
6272
6273    For non-recursive calls, LHSTYPE should be a function, pointer to
6274    function, or a pointer to member function.  */
6275
6276 tree
6277 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6278 {
6279   tsubst_flags_t flags_in = flags;
6280   tree access_path = NULL_TREE;
6281
6282   flags &= ~tf_ptrmem_ok;
6283
6284   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
6285     {
6286       if (flags & tf_error)
6287         error ("not enough type information");
6288       return error_mark_node;
6289     }
6290
6291   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6292     {
6293       if (same_type_p (lhstype, TREE_TYPE (rhs)))
6294         return rhs;
6295       if (flag_ms_extensions
6296           && TYPE_PTRMEMFUNC_P (lhstype)
6297           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6298         /* Microsoft allows `A::f' to be resolved to a
6299            pointer-to-member.  */
6300         ;
6301       else
6302         {
6303           if (flags & tf_error)
6304             error ("argument of type %qT does not match %qT",
6305                    TREE_TYPE (rhs), lhstype);
6306           return error_mark_node;
6307         }
6308     }
6309
6310   if (TREE_CODE (rhs) == BASELINK)
6311     {
6312       access_path = BASELINK_ACCESS_BINFO (rhs);
6313       rhs = BASELINK_FUNCTIONS (rhs);
6314     }
6315
6316   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6317      deduce any type information.  */
6318   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6319     {
6320       if (flags & tf_error)
6321         error ("not enough type information");
6322       return error_mark_node;
6323     }
6324
6325   /* There only a few kinds of expressions that may have a type
6326      dependent on overload resolution.  */
6327   gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6328               || TREE_CODE (rhs) == COMPONENT_REF
6329               || really_overloaded_fn (rhs)
6330               || (flag_ms_extensions && TREE_CODE (rhs) == FUNCTION_DECL));
6331
6332   /* This should really only be used when attempting to distinguish
6333      what sort of a pointer to function we have.  For now, any
6334      arithmetic operation which is not supported on pointers
6335      is rejected as an error.  */
6336
6337   switch (TREE_CODE (rhs))
6338     {
6339     case COMPONENT_REF:
6340       {
6341         tree member = TREE_OPERAND (rhs, 1);
6342
6343         member = instantiate_type (lhstype, member, flags);
6344         if (member != error_mark_node
6345             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6346           /* Do not lose object's side effects.  */
6347           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6348                          TREE_OPERAND (rhs, 0), member);
6349         return member;
6350       }
6351
6352     case OFFSET_REF:
6353       rhs = TREE_OPERAND (rhs, 1);
6354       if (BASELINK_P (rhs))
6355         return instantiate_type (lhstype, rhs, flags_in);
6356
6357       /* This can happen if we are forming a pointer-to-member for a
6358          member template.  */
6359       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6360
6361       /* Fall through.  */
6362
6363     case TEMPLATE_ID_EXPR:
6364       {
6365         tree fns = TREE_OPERAND (rhs, 0);
6366         tree args = TREE_OPERAND (rhs, 1);
6367
6368         return
6369           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6370                                                   /*template_only=*/true,
6371                                                   args, access_path);
6372       }
6373
6374     case OVERLOAD:
6375     case FUNCTION_DECL:
6376       return
6377         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6378                                                 /*template_only=*/false,
6379                                                 /*explicit_targs=*/NULL_TREE,
6380                                                 access_path);
6381
6382     case ADDR_EXPR:
6383     {
6384       if (PTRMEM_OK_P (rhs))
6385         flags |= tf_ptrmem_ok;
6386
6387       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6388     }
6389
6390     case ERROR_MARK:
6391       return error_mark_node;
6392
6393     default:
6394       gcc_unreachable ();
6395     }
6396   return error_mark_node;
6397 }
6398 \f
6399 /* Return the name of the virtual function pointer field
6400    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6401    this may have to look back through base types to find the
6402    ultimate field name.  (For single inheritance, these could
6403    all be the same name.  Who knows for multiple inheritance).  */
6404
6405 static tree
6406 get_vfield_name (tree type)
6407 {
6408   tree binfo, base_binfo;
6409   char *buf;
6410
6411   for (binfo = TYPE_BINFO (type);
6412        BINFO_N_BASE_BINFOS (binfo);
6413        binfo = base_binfo)
6414     {
6415       base_binfo = BINFO_BASE_BINFO (binfo, 0);
6416
6417       if (BINFO_VIRTUAL_P (base_binfo)
6418           || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6419         break;
6420     }
6421
6422   type = BINFO_TYPE (binfo);
6423   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6424                          + TYPE_NAME_LENGTH (type) + 2);
6425   sprintf (buf, VFIELD_NAME_FORMAT,
6426            IDENTIFIER_POINTER (constructor_name (type)));
6427   return get_identifier (buf);
6428 }
6429
6430 void
6431 print_class_statistics (void)
6432 {
6433 #ifdef GATHER_STATISTICS
6434   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6435   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6436   if (n_vtables)
6437     {
6438       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6439                n_vtables, n_vtable_searches);
6440       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6441                n_vtable_entries, n_vtable_elems);
6442     }
6443 #endif
6444 }
6445
6446 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6447    according to [class]:
6448                                           The class-name is also inserted
6449    into  the scope of the class itself.  For purposes of access checking,
6450    the inserted class name is treated as if it were a public member name.  */
6451
6452 void
6453 build_self_reference (void)
6454 {
6455   tree name = constructor_name (current_class_type);
6456   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6457   tree saved_cas;
6458
6459   DECL_NONLOCAL (value) = 1;
6460   DECL_CONTEXT (value) = current_class_type;
6461   DECL_ARTIFICIAL (value) = 1;
6462   SET_DECL_SELF_REFERENCE_P (value);
6463
6464   if (processing_template_decl)
6465     value = push_template_decl (value);
6466
6467   saved_cas = current_access_specifier;
6468   current_access_specifier = access_public_node;
6469   finish_member_declaration (value);
6470   current_access_specifier = saved_cas;
6471 }
6472
6473 /* Returns 1 if TYPE contains only padding bytes.  */
6474
6475 int
6476 is_empty_class (tree type)
6477 {
6478   if (type == error_mark_node)
6479     return 0;
6480
6481   if (! CLASS_TYPE_P (type))
6482     return 0;
6483
6484   /* In G++ 3.2, whether or not a class was empty was determined by
6485      looking at its size.  */
6486   if (abi_version_at_least (2))
6487     return CLASSTYPE_EMPTY_P (type);
6488   else
6489     return integer_zerop (CLASSTYPE_SIZE (type));
6490 }
6491
6492 /* Returns true if TYPE contains an empty class.  */
6493
6494 static bool
6495 contains_empty_class_p (tree type)
6496 {
6497   if (is_empty_class (type))
6498     return true;
6499   if (CLASS_TYPE_P (type))
6500     {
6501       tree field;
6502       tree binfo;
6503       tree base_binfo;
6504       int i;
6505
6506       for (binfo = TYPE_BINFO (type), i = 0;
6507            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6508         if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6509           return true;
6510       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6511         if (TREE_CODE (field) == FIELD_DECL
6512             && !DECL_ARTIFICIAL (field)
6513             && is_empty_class (TREE_TYPE (field)))
6514           return true;
6515     }
6516   else if (TREE_CODE (type) == ARRAY_TYPE)
6517     return contains_empty_class_p (TREE_TYPE (type));
6518   return false;
6519 }
6520
6521 /* Returns true if TYPE contains no actual data, just various
6522    possible combinations of empty classes.  */
6523
6524 bool
6525 is_really_empty_class (tree type)
6526 {
6527   if (is_empty_class (type))
6528     return true;
6529   if (CLASS_TYPE_P (type))
6530     {
6531       tree field;
6532       tree binfo;
6533       tree base_binfo;
6534       int i;
6535
6536       for (binfo = TYPE_BINFO (type), i = 0;
6537            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6538         if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
6539           return false;
6540       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6541         if (TREE_CODE (field) == FIELD_DECL
6542             && !DECL_ARTIFICIAL (field)
6543             && !is_really_empty_class (TREE_TYPE (field)))
6544           return false;
6545       return true;
6546     }
6547   else if (TREE_CODE (type) == ARRAY_TYPE)
6548     return is_really_empty_class (TREE_TYPE (type));
6549   return false;
6550 }
6551
6552 /* Note that NAME was looked up while the current class was being
6553    defined and that the result of that lookup was DECL.  */
6554
6555 void
6556 maybe_note_name_used_in_class (tree name, tree decl)
6557 {
6558   splay_tree names_used;
6559
6560   /* If we're not defining a class, there's nothing to do.  */
6561   if (!(innermost_scope_kind() == sk_class
6562         && TYPE_BEING_DEFINED (current_class_type)))
6563     return;
6564
6565   /* If there's already a binding for this NAME, then we don't have
6566      anything to worry about.  */
6567   if (lookup_member (current_class_type, name,
6568                      /*protect=*/0, /*want_type=*/false))
6569     return;
6570
6571   if (!current_class_stack[current_class_depth - 1].names_used)
6572     current_class_stack[current_class_depth - 1].names_used
6573       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6574   names_used = current_class_stack[current_class_depth - 1].names_used;
6575
6576   splay_tree_insert (names_used,
6577                      (splay_tree_key) name,
6578                      (splay_tree_value) decl);
6579 }
6580
6581 /* Note that NAME was declared (as DECL) in the current class.  Check
6582    to see that the declaration is valid.  */
6583
6584 void
6585 note_name_declared_in_class (tree name, tree decl)
6586 {
6587   splay_tree names_used;
6588   splay_tree_node n;
6589
6590   /* Look to see if we ever used this name.  */
6591   names_used
6592     = current_class_stack[current_class_depth - 1].names_used;
6593   if (!names_used)
6594     return;
6595
6596   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6597   if (n)
6598     {
6599       /* [basic.scope.class]
6600
6601          A name N used in a class S shall refer to the same declaration
6602          in its context and when re-evaluated in the completed scope of
6603          S.  */
6604       permerror (input_location, "declaration of %q#D", decl);
6605       permerror (input_location, "changes meaning of %qD from %q+#D",
6606                DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
6607     }
6608 }
6609
6610 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6611    Secondary vtables are merged with primary vtables; this function
6612    will return the VAR_DECL for the primary vtable.  */
6613
6614 tree
6615 get_vtbl_decl_for_binfo (tree binfo)
6616 {
6617   tree decl;
6618
6619   decl = BINFO_VTABLE (binfo);
6620   if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR)
6621     {
6622       gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6623       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6624     }
6625   if (decl)
6626     gcc_assert (TREE_CODE (decl) == VAR_DECL);
6627   return decl;
6628 }
6629
6630
6631 /* Returns the binfo for the primary base of BINFO.  If the resulting
6632    BINFO is a virtual base, and it is inherited elsewhere in the
6633    hierarchy, then the returned binfo might not be the primary base of
6634    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6635    BINFO_LOST_PRIMARY_P to be sure.  */
6636
6637 static tree
6638 get_primary_binfo (tree binfo)
6639 {
6640   tree primary_base;
6641
6642   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6643   if (!primary_base)
6644     return NULL_TREE;
6645
6646   return copied_binfo (primary_base, binfo);
6647 }
6648
6649 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6650
6651 static int
6652 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6653 {
6654   if (!indented_p)
6655     fprintf (stream, "%*s", indent, "");
6656   return 1;
6657 }
6658
6659 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6660    INDENT should be zero when called from the top level; it is
6661    incremented recursively.  IGO indicates the next expected BINFO in
6662    inheritance graph ordering.  */
6663
6664 static tree
6665 dump_class_hierarchy_r (FILE *stream,
6666                         int flags,
6667                         tree binfo,
6668                         tree igo,
6669                         int indent)
6670 {
6671   int indented = 0;
6672   tree base_binfo;
6673   int i;
6674
6675   indented = maybe_indent_hierarchy (stream, indent, 0);
6676   fprintf (stream, "%s (0x%lx) ",
6677            type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6678            (unsigned long) binfo);
6679   if (binfo != igo)
6680     {
6681       fprintf (stream, "alternative-path\n");
6682       return igo;
6683     }
6684   igo = TREE_CHAIN (binfo);
6685
6686   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6687            tree_low_cst (BINFO_OFFSET (binfo), 0));
6688   if (is_empty_class (BINFO_TYPE (binfo)))
6689     fprintf (stream, " empty");
6690   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6691     fprintf (stream, " nearly-empty");
6692   if (BINFO_VIRTUAL_P (binfo))
6693     fprintf (stream, " virtual");
6694   fprintf (stream, "\n");
6695
6696   indented = 0;
6697   if (BINFO_PRIMARY_P (binfo))
6698     {
6699       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6700       fprintf (stream, " primary-for %s (0x%lx)",
6701                type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
6702                                TFF_PLAIN_IDENTIFIER),
6703                (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
6704     }
6705   if (BINFO_LOST_PRIMARY_P (binfo))
6706     {
6707       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6708       fprintf (stream, " lost-primary");
6709     }
6710   if (indented)
6711     fprintf (stream, "\n");
6712
6713   if (!(flags & TDF_SLIM))
6714     {
6715       int indented = 0;
6716
6717       if (BINFO_SUBVTT_INDEX (binfo))
6718         {
6719           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6720           fprintf (stream, " subvttidx=%s",
6721                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6722                                    TFF_PLAIN_IDENTIFIER));
6723         }
6724       if (BINFO_VPTR_INDEX (binfo))
6725         {
6726           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6727           fprintf (stream, " vptridx=%s",
6728                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6729                                    TFF_PLAIN_IDENTIFIER));
6730         }
6731       if (BINFO_VPTR_FIELD (binfo))
6732         {
6733           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6734           fprintf (stream, " vbaseoffset=%s",
6735                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6736                                    TFF_PLAIN_IDENTIFIER));
6737         }
6738       if (BINFO_VTABLE (binfo))
6739         {
6740           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6741           fprintf (stream, " vptr=%s",
6742                    expr_as_string (BINFO_VTABLE (binfo),
6743                                    TFF_PLAIN_IDENTIFIER));
6744         }
6745
6746       if (indented)
6747         fprintf (stream, "\n");
6748     }
6749
6750   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
6751     igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
6752
6753   return igo;
6754 }
6755
6756 /* Dump the BINFO hierarchy for T.  */
6757
6758 static void
6759 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6760 {
6761   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6762   fprintf (stream, "   size=%lu align=%lu\n",
6763            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6764            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6765   fprintf (stream, "   base size=%lu base align=%lu\n",
6766            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6767                            / BITS_PER_UNIT),
6768            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6769                            / BITS_PER_UNIT));
6770   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6771   fprintf (stream, "\n");
6772 }
6773
6774 /* Debug interface to hierarchy dumping.  */
6775
6776 void
6777 debug_class (tree t)
6778 {
6779   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6780 }
6781
6782 static void
6783 dump_class_hierarchy (tree t)
6784 {
6785   int flags;
6786   FILE *stream = dump_begin (TDI_class, &flags);
6787
6788   if (stream)
6789     {
6790       dump_class_hierarchy_1 (stream, flags, t);
6791       dump_end (TDI_class, stream);
6792     }
6793 }
6794
6795 static void
6796 dump_array (FILE * stream, tree decl)
6797 {
6798   tree value;
6799   unsigned HOST_WIDE_INT ix;
6800   HOST_WIDE_INT elt;
6801   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6802
6803   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6804          / BITS_PER_UNIT);
6805   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6806   fprintf (stream, " %s entries",
6807            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6808                            TFF_PLAIN_IDENTIFIER));
6809   fprintf (stream, "\n");
6810
6811   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
6812                               ix, value)
6813     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6814              expr_as_string (value, TFF_PLAIN_IDENTIFIER));
6815 }
6816
6817 static void
6818 dump_vtable (tree t, tree binfo, tree vtable)
6819 {
6820   int flags;
6821   FILE *stream = dump_begin (TDI_class, &flags);
6822
6823   if (!stream)
6824     return;
6825
6826   if (!(flags & TDF_SLIM))
6827     {
6828       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6829
6830       fprintf (stream, "%s for %s",
6831                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6832                type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
6833       if (ctor_vtbl_p)
6834         {
6835           if (!BINFO_VIRTUAL_P (binfo))
6836             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6837           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6838         }
6839       fprintf (stream, "\n");
6840       dump_array (stream, vtable);
6841       fprintf (stream, "\n");
6842     }
6843
6844   dump_end (TDI_class, stream);
6845 }
6846
6847 static void
6848 dump_vtt (tree t, tree vtt)
6849 {
6850   int flags;
6851   FILE *stream = dump_begin (TDI_class, &flags);
6852
6853   if (!stream)
6854     return;
6855
6856   if (!(flags & TDF_SLIM))
6857     {
6858       fprintf (stream, "VTT for %s\n",
6859                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6860       dump_array (stream, vtt);
6861       fprintf (stream, "\n");
6862     }
6863
6864   dump_end (TDI_class, stream);
6865 }
6866
6867 /* Dump a function or thunk and its thunkees.  */
6868
6869 static void
6870 dump_thunk (FILE *stream, int indent, tree thunk)
6871 {
6872   static const char spaces[] = "        ";
6873   tree name = DECL_NAME (thunk);
6874   tree thunks;
6875
6876   fprintf (stream, "%.*s%p %s %s", indent, spaces,
6877            (void *)thunk,
6878            !DECL_THUNK_P (thunk) ? "function"
6879            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6880            name ? IDENTIFIER_POINTER (name) : "<unset>");
6881   if (DECL_THUNK_P (thunk))
6882     {
6883       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6884       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6885
6886       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6887       if (!virtual_adjust)
6888         /*NOP*/;
6889       else if (DECL_THIS_THUNK_P (thunk))
6890         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
6891                  tree_low_cst (virtual_adjust, 0));
6892       else
6893         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6894                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6895                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6896       if (THUNK_ALIAS (thunk))
6897         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6898     }
6899   fprintf (stream, "\n");
6900   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6901     dump_thunk (stream, indent + 2, thunks);
6902 }
6903
6904 /* Dump the thunks for FN.  */
6905
6906 void
6907 debug_thunks (tree fn)
6908 {
6909   dump_thunk (stderr, 0, fn);
6910 }
6911
6912 /* Virtual function table initialization.  */
6913
6914 /* Create all the necessary vtables for T and its base classes.  */
6915
6916 static void
6917 finish_vtbls (tree t)
6918 {
6919   tree list;
6920   tree vbase;
6921
6922   /* We lay out the primary and secondary vtables in one contiguous
6923      vtable.  The primary vtable is first, followed by the non-virtual
6924      secondary vtables in inheritance graph order.  */
6925   list = build_tree_list (BINFO_VTABLE (TYPE_BINFO (t)), NULL_TREE);
6926   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6927                          TYPE_BINFO (t), t, list);
6928
6929   /* Then come the virtual bases, also in inheritance graph order.  */
6930   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6931     {
6932       if (!BINFO_VIRTUAL_P (vbase))
6933         continue;
6934       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6935     }
6936
6937   if (BINFO_VTABLE (TYPE_BINFO (t)))
6938     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6939 }
6940
6941 /* Initialize the vtable for BINFO with the INITS.  */
6942
6943 static void
6944 initialize_vtable (tree binfo, tree inits)
6945 {
6946   tree decl;
6947
6948   layout_vtable_decl (binfo, list_length (inits));
6949   decl = get_vtbl_decl_for_binfo (binfo);
6950   initialize_artificial_var (decl, inits);
6951   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6952 }
6953
6954 /* Build the VTT (virtual table table) for T.
6955    A class requires a VTT if it has virtual bases.
6956
6957    This holds
6958    1 - primary virtual pointer for complete object T
6959    2 - secondary VTTs for each direct non-virtual base of T which requires a
6960        VTT
6961    3 - secondary virtual pointers for each direct or indirect base of T which
6962        has virtual bases or is reachable via a virtual path from T.
6963    4 - secondary VTTs for each direct or indirect virtual base of T.
6964
6965    Secondary VTTs look like complete object VTTs without part 4.  */
6966
6967 static void
6968 build_vtt (tree t)
6969 {
6970   tree inits;
6971   tree type;
6972   tree vtt;
6973   tree index;
6974
6975   /* Build up the initializers for the VTT.  */
6976   inits = NULL_TREE;
6977   index = size_zero_node;
6978   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6979
6980   /* If we didn't need a VTT, we're done.  */
6981   if (!inits)
6982     return;
6983
6984   /* Figure out the type of the VTT.  */
6985   type = build_index_type (size_int (list_length (inits) - 1));
6986   type = build_cplus_array_type (const_ptr_type_node, type);
6987
6988   /* Now, build the VTT object itself.  */
6989   vtt = build_vtable (t, mangle_vtt_for_type (t), type);
6990   initialize_artificial_var (vtt, inits);
6991   /* Add the VTT to the vtables list.  */
6992   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6993   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6994
6995   dump_vtt (t, vtt);
6996 }
6997
6998 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6999    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7000    and CHAIN the vtable pointer for this binfo after construction is
7001    complete.  VALUE can also be another BINFO, in which case we recurse.  */
7002
7003 static tree
7004 binfo_ctor_vtable (tree binfo)
7005 {
7006   tree vt;
7007
7008   while (1)
7009     {
7010       vt = BINFO_VTABLE (binfo);
7011       if (TREE_CODE (vt) == TREE_LIST)
7012         vt = TREE_VALUE (vt);
7013       if (TREE_CODE (vt) == TREE_BINFO)
7014         binfo = vt;
7015       else
7016         break;
7017     }
7018
7019   return vt;
7020 }
7021
7022 /* Data for secondary VTT initialization.  */
7023 typedef struct secondary_vptr_vtt_init_data_s
7024 {
7025   /* Is this the primary VTT? */
7026   bool top_level_p;
7027
7028   /* Current index into the VTT.  */
7029   tree index;
7030
7031   /* TREE_LIST of initializers built up.  */
7032   tree inits;
7033
7034   /* The type being constructed by this secondary VTT.  */
7035   tree type_being_constructed;
7036 } secondary_vptr_vtt_init_data;
7037
7038 /* Recursively build the VTT-initializer for BINFO (which is in the
7039    hierarchy dominated by T).  INITS points to the end of the initializer
7040    list to date.  INDEX is the VTT index where the next element will be
7041    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7042    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
7043    for virtual bases of T. When it is not so, we build the constructor
7044    vtables for the BINFO-in-T variant.  */
7045
7046 static tree *
7047 build_vtt_inits (tree binfo, tree t, tree *inits, tree *index)
7048 {
7049   int i;
7050   tree b;
7051   tree init;
7052   tree secondary_vptrs;
7053   secondary_vptr_vtt_init_data data;
7054   int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7055
7056   /* We only need VTTs for subobjects with virtual bases.  */
7057   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7058     return inits;
7059
7060   /* We need to use a construction vtable if this is not the primary
7061      VTT.  */
7062   if (!top_level_p)
7063     {
7064       build_ctor_vtbl_group (binfo, t);
7065
7066       /* Record the offset in the VTT where this sub-VTT can be found.  */
7067       BINFO_SUBVTT_INDEX (binfo) = *index;
7068     }
7069
7070   /* Add the address of the primary vtable for the complete object.  */
7071   init = binfo_ctor_vtable (binfo);
7072   *inits = build_tree_list (NULL_TREE, init);
7073   inits = &TREE_CHAIN (*inits);
7074   if (top_level_p)
7075     {
7076       gcc_assert (!BINFO_VPTR_INDEX (binfo));
7077       BINFO_VPTR_INDEX (binfo) = *index;
7078     }
7079   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
7080
7081   /* Recursively add the secondary VTTs for non-virtual bases.  */
7082   for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
7083     if (!BINFO_VIRTUAL_P (b))
7084       inits = build_vtt_inits (b, t, inits, index);
7085
7086   /* Add secondary virtual pointers for all subobjects of BINFO with
7087      either virtual bases or reachable along a virtual path, except
7088      subobjects that are non-virtual primary bases.  */
7089   data.top_level_p = top_level_p;
7090   data.index = *index;
7091   data.inits = NULL;
7092   data.type_being_constructed = BINFO_TYPE (binfo);
7093
7094   dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
7095
7096   *index = data.index;
7097
7098   /* The secondary vptrs come back in reverse order.  After we reverse
7099      them, and add the INITS, the last init will be the first element
7100      of the chain.  */
7101   secondary_vptrs = data.inits;
7102   if (secondary_vptrs)
7103     {
7104       *inits = nreverse (secondary_vptrs);
7105       inits = &TREE_CHAIN (secondary_vptrs);
7106       gcc_assert (*inits == NULL_TREE);
7107     }
7108
7109   if (top_level_p)
7110     /* Add the secondary VTTs for virtual bases in inheritance graph
7111        order.  */
7112     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
7113       {
7114         if (!BINFO_VIRTUAL_P (b))
7115           continue;
7116
7117         inits = build_vtt_inits (b, t, inits, index);
7118       }
7119   else
7120     /* Remove the ctor vtables we created.  */
7121     dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
7122
7123   return inits;
7124 }
7125
7126 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo for the base
7127    in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure.  */
7128
7129 static tree
7130 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
7131 {
7132   secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
7133
7134   /* We don't care about bases that don't have vtables.  */
7135   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7136     return dfs_skip_bases;
7137
7138   /* We're only interested in proper subobjects of the type being
7139      constructed.  */
7140   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
7141     return NULL_TREE;
7142
7143   /* We're only interested in bases with virtual bases or reachable
7144      via a virtual path from the type being constructed.  */
7145   if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7146         || binfo_via_virtual (binfo, data->type_being_constructed)))
7147     return dfs_skip_bases;
7148
7149   /* We're not interested in non-virtual primary bases.  */
7150   if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
7151     return NULL_TREE;
7152
7153   /* Record the index where this secondary vptr can be found.  */
7154   if (data->top_level_p)
7155     {
7156       gcc_assert (!BINFO_VPTR_INDEX (binfo));
7157       BINFO_VPTR_INDEX (binfo) = data->index;
7158
7159       if (BINFO_VIRTUAL_P (binfo))
7160         {
7161           /* It's a primary virtual base, and this is not a
7162              construction vtable.  Find the base this is primary of in
7163              the inheritance graph, and use that base's vtable
7164              now.  */
7165           while (BINFO_PRIMARY_P (binfo))
7166             binfo = BINFO_INHERITANCE_CHAIN (binfo);
7167         }
7168     }
7169
7170   /* Add the initializer for the secondary vptr itself.  */
7171   data->inits = tree_cons (NULL_TREE, binfo_ctor_vtable (binfo), data->inits);
7172
7173   /* Advance the vtt index.  */
7174   data->index = size_binop (PLUS_EXPR, data->index,
7175                             TYPE_SIZE_UNIT (ptr_type_node));
7176
7177   return NULL_TREE;
7178 }
7179
7180 /* Called from build_vtt_inits via dfs_walk. After building
7181    constructor vtables and generating the sub-vtt from them, we need
7182    to restore the BINFO_VTABLES that were scribbled on.  DATA is the
7183    binfo of the base whose sub vtt was generated.  */
7184
7185 static tree
7186 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7187 {
7188   tree vtable = BINFO_VTABLE (binfo);
7189
7190   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7191     /* If this class has no vtable, none of its bases do.  */
7192     return dfs_skip_bases;
7193
7194   if (!vtable)
7195     /* This might be a primary base, so have no vtable in this
7196        hierarchy.  */
7197     return NULL_TREE;
7198
7199   /* If we scribbled the construction vtable vptr into BINFO, clear it
7200      out now.  */
7201   if (TREE_CODE (vtable) == TREE_LIST
7202       && (TREE_PURPOSE (vtable) == (tree) data))
7203     BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
7204
7205   return NULL_TREE;
7206 }
7207
7208 /* Build the construction vtable group for BINFO which is in the
7209    hierarchy dominated by T.  */
7210
7211 static void
7212 build_ctor_vtbl_group (tree binfo, tree t)
7213 {
7214   tree list;
7215   tree type;
7216   tree vtbl;
7217   tree inits;
7218   tree id;
7219   tree vbase;
7220
7221   /* See if we've already created this construction vtable group.  */
7222   id = mangle_ctor_vtbl_for_type (t, binfo);
7223   if (IDENTIFIER_GLOBAL_VALUE (id))
7224     return;
7225
7226   gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
7227   /* Build a version of VTBL (with the wrong type) for use in
7228      constructing the addresses of secondary vtables in the
7229      construction vtable group.  */
7230   vtbl = build_vtable (t, id, ptr_type_node);
7231   DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
7232   list = build_tree_list (vtbl, NULL_TREE);
7233   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7234                          binfo, t, list);
7235
7236   /* Add the vtables for each of our virtual bases using the vbase in T
7237      binfo.  */
7238   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7239        vbase;
7240        vbase = TREE_CHAIN (vbase))
7241     {
7242       tree b;
7243
7244       if (!BINFO_VIRTUAL_P (vbase))
7245         continue;
7246       b = copied_binfo (vbase, binfo);
7247
7248       accumulate_vtbl_inits (b, vbase, binfo, t, list);
7249     }
7250   inits = TREE_VALUE (list);
7251
7252   /* Figure out the type of the construction vtable.  */
7253   type = build_index_type (size_int (list_length (inits) - 1));
7254   type = build_cplus_array_type (vtable_entry_type, type);
7255   layout_type (type);
7256   TREE_TYPE (vtbl) = type;
7257   DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE;
7258   layout_decl (vtbl, 0);
7259
7260   /* Initialize the construction vtable.  */
7261   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7262   initialize_artificial_var (vtbl, inits);
7263   dump_vtable (t, binfo, vtbl);
7264 }
7265
7266 /* Add the vtbl initializers for BINFO (and its bases other than
7267    non-virtual primaries) to the list of INITS.  BINFO is in the
7268    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
7269    the constructor the vtbl inits should be accumulated for. (If this
7270    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7271    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7272    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7273    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7274    but are not necessarily the same in terms of layout.  */
7275
7276 static void
7277 accumulate_vtbl_inits (tree binfo,
7278                        tree orig_binfo,
7279                        tree rtti_binfo,
7280                        tree t,
7281                        tree inits)
7282 {
7283   int i;
7284   tree base_binfo;
7285   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7286
7287   gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
7288
7289   /* If it doesn't have a vptr, we don't do anything.  */
7290   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7291     return;
7292
7293   /* If we're building a construction vtable, we're not interested in
7294      subobjects that don't require construction vtables.  */
7295   if (ctor_vtbl_p
7296       && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7297       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7298     return;
7299
7300   /* Build the initializers for the BINFO-in-T vtable.  */
7301   TREE_VALUE (inits)
7302     = chainon (TREE_VALUE (inits),
7303                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7304                                           rtti_binfo, t, inits));
7305
7306   /* Walk the BINFO and its bases.  We walk in preorder so that as we
7307      initialize each vtable we can figure out at what offset the
7308      secondary vtable lies from the primary vtable.  We can't use
7309      dfs_walk here because we need to iterate through bases of BINFO
7310      and RTTI_BINFO simultaneously.  */
7311   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7312     {
7313       /* Skip virtual bases.  */
7314       if (BINFO_VIRTUAL_P (base_binfo))
7315         continue;
7316       accumulate_vtbl_inits (base_binfo,
7317                              BINFO_BASE_BINFO (orig_binfo, i),
7318                              rtti_binfo, t,
7319                              inits);
7320     }
7321 }
7322
7323 /* Called from accumulate_vtbl_inits.  Returns the initializers for
7324    the BINFO vtable.  */
7325
7326 static tree
7327 dfs_accumulate_vtbl_inits (tree binfo,
7328                            tree orig_binfo,
7329                            tree rtti_binfo,
7330                            tree t,
7331                            tree l)
7332 {
7333   tree inits = NULL_TREE;
7334   tree vtbl = NULL_TREE;
7335   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7336
7337   if (ctor_vtbl_p
7338       && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7339     {
7340       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7341          primary virtual base.  If it is not the same primary in
7342          the hierarchy of T, we'll need to generate a ctor vtable
7343          for it, to place at its location in T.  If it is the same
7344          primary, we still need a VTT entry for the vtable, but it
7345          should point to the ctor vtable for the base it is a
7346          primary for within the sub-hierarchy of RTTI_BINFO.
7347
7348          There are three possible cases:
7349
7350          1) We are in the same place.
7351          2) We are a primary base within a lost primary virtual base of
7352          RTTI_BINFO.
7353          3) We are primary to something not a base of RTTI_BINFO.  */
7354
7355       tree b;
7356       tree last = NULL_TREE;
7357
7358       /* First, look through the bases we are primary to for RTTI_BINFO
7359          or a virtual base.  */
7360       b = binfo;
7361       while (BINFO_PRIMARY_P (b))
7362         {
7363           b = BINFO_INHERITANCE_CHAIN (b);
7364           last = b;
7365           if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7366             goto found;
7367         }
7368       /* If we run out of primary links, keep looking down our
7369          inheritance chain; we might be an indirect primary.  */
7370       for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7371         if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7372           break;
7373     found:
7374
7375       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7376          base B and it is a base of RTTI_BINFO, this is case 2.  In
7377          either case, we share our vtable with LAST, i.e. the
7378          derived-most base within B of which we are a primary.  */
7379       if (b == rtti_binfo
7380           || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7381         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7382            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7383            binfo_ctor_vtable after everything's been set up.  */
7384         vtbl = last;
7385
7386       /* Otherwise, this is case 3 and we get our own.  */
7387     }
7388   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7389     return inits;
7390
7391   if (!vtbl)
7392     {
7393       tree index;
7394       int non_fn_entries;
7395
7396       /* Compute the initializer for this vtable.  */
7397       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7398                                       &non_fn_entries);
7399
7400       /* Figure out the position to which the VPTR should point.  */
7401       vtbl = TREE_PURPOSE (l);
7402       vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, vtbl);
7403       index = size_binop (PLUS_EXPR,
7404                           size_int (non_fn_entries),
7405                           size_int (list_length (TREE_VALUE (l))));
7406       index = size_binop (MULT_EXPR,
7407                           TYPE_SIZE_UNIT (vtable_entry_type),
7408                           index);
7409       vtbl = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7410     }
7411
7412   if (ctor_vtbl_p)
7413     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7414        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7415        straighten this out.  */
7416     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7417   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7418     inits = NULL_TREE;
7419   else
7420      /* For an ordinary vtable, set BINFO_VTABLE.  */
7421     BINFO_VTABLE (binfo) = vtbl;
7422
7423   return inits;
7424 }
7425
7426 static GTY(()) tree abort_fndecl_addr;
7427
7428 /* Construct the initializer for BINFO's virtual function table.  BINFO
7429    is part of the hierarchy dominated by T.  If we're building a
7430    construction vtable, the ORIG_BINFO is the binfo we should use to
7431    find the actual function pointers to put in the vtable - but they
7432    can be overridden on the path to most-derived in the graph that
7433    ORIG_BINFO belongs.  Otherwise,
7434    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7435    BINFO that should be indicated by the RTTI information in the
7436    vtable; it will be a base class of T, rather than T itself, if we
7437    are building a construction vtable.
7438
7439    The value returned is a TREE_LIST suitable for wrapping in a
7440    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7441    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7442    number of non-function entries in the vtable.
7443
7444    It might seem that this function should never be called with a
7445    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7446    base is always subsumed by a derived class vtable.  However, when
7447    we are building construction vtables, we do build vtables for
7448    primary bases; we need these while the primary base is being
7449    constructed.  */
7450
7451 static tree
7452 build_vtbl_initializer (tree binfo,
7453                         tree orig_binfo,
7454                         tree t,
7455                         tree rtti_binfo,
7456                         int* non_fn_entries_p)
7457 {
7458   tree v, b;
7459   tree vfun_inits;
7460   vtbl_init_data vid;
7461   unsigned ix;
7462   tree vbinfo;
7463   VEC(tree,gc) *vbases;
7464
7465   /* Initialize VID.  */
7466   memset (&vid, 0, sizeof (vid));
7467   vid.binfo = binfo;
7468   vid.derived = t;
7469   vid.rtti_binfo = rtti_binfo;
7470   vid.last_init = &vid.inits;
7471   vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7472   vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7473   vid.generate_vcall_entries = true;
7474   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7475   vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7476
7477   /* Add entries to the vtable for RTTI.  */
7478   build_rtti_vtbl_entries (binfo, &vid);
7479
7480   /* Create an array for keeping track of the functions we've
7481      processed.  When we see multiple functions with the same
7482      signature, we share the vcall offsets.  */
7483   vid.fns = VEC_alloc (tree, gc, 32);
7484   /* Add the vcall and vbase offset entries.  */
7485   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7486
7487   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7488      build_vbase_offset_vtbl_entries.  */
7489   for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7490        VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7491     BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7492
7493   /* If the target requires padding between data entries, add that now.  */
7494   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7495     {
7496       tree cur, *prev;
7497
7498       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7499         {
7500           tree add = cur;
7501           int i;
7502
7503           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7504             add = tree_cons (NULL_TREE,
7505                              build1 (NOP_EXPR, vtable_entry_type,
7506                                      null_pointer_node),
7507                              add);
7508           *prev = add;
7509         }
7510     }
7511
7512   if (non_fn_entries_p)
7513     *non_fn_entries_p = list_length (vid.inits);
7514
7515   /* Go through all the ordinary virtual functions, building up
7516      initializers.  */
7517   vfun_inits = NULL_TREE;
7518   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7519     {
7520       tree delta;
7521       tree vcall_index;
7522       tree fn, fn_original;
7523       tree init = NULL_TREE;
7524
7525       fn = BV_FN (v);
7526       fn_original = fn;
7527       if (DECL_THUNK_P (fn))
7528         {
7529           if (!DECL_NAME (fn))
7530             finish_thunk (fn);
7531           if (THUNK_ALIAS (fn))
7532             {
7533               fn = THUNK_ALIAS (fn);
7534               BV_FN (v) = fn;
7535             }
7536           fn_original = THUNK_TARGET (fn);
7537         }
7538
7539       /* If the only definition of this function signature along our
7540          primary base chain is from a lost primary, this vtable slot will
7541          never be used, so just zero it out.  This is important to avoid
7542          requiring extra thunks which cannot be generated with the function.
7543
7544          We first check this in update_vtable_entry_for_fn, so we handle
7545          restored primary bases properly; we also need to do it here so we
7546          zero out unused slots in ctor vtables, rather than filling them
7547          with erroneous values (though harmless, apart from relocation
7548          costs).  */
7549       for (b = binfo; ; b = get_primary_binfo (b))
7550         {
7551           /* We found a defn before a lost primary; go ahead as normal.  */
7552           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7553             break;
7554
7555           /* The nearest definition is from a lost primary; clear the
7556              slot.  */
7557           if (BINFO_LOST_PRIMARY_P (b))
7558             {
7559               init = size_zero_node;
7560               break;
7561             }
7562         }
7563
7564       if (! init)
7565         {
7566           /* Pull the offset for `this', and the function to call, out of
7567              the list.  */
7568           delta = BV_DELTA (v);
7569           vcall_index = BV_VCALL_INDEX (v);
7570
7571           gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7572           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7573
7574           /* You can't call an abstract virtual function; it's abstract.
7575              So, we replace these functions with __pure_virtual.  */
7576           if (DECL_PURE_VIRTUAL_P (fn_original))
7577             {
7578               fn = abort_fndecl;
7579               if (abort_fndecl_addr == NULL)
7580                 abort_fndecl_addr = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7581               init = abort_fndecl_addr;
7582             }
7583           else
7584             {
7585               if (!integer_zerop (delta) || vcall_index)
7586                 {
7587                   fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7588                   if (!DECL_NAME (fn))
7589                     finish_thunk (fn);
7590                 }
7591               /* Take the address of the function, considering it to be of an
7592                  appropriate generic type.  */
7593               init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7594             }
7595         }
7596
7597       /* And add it to the chain of initializers.  */
7598       if (TARGET_VTABLE_USES_DESCRIPTORS)
7599         {
7600           int i;
7601           if (init == size_zero_node)
7602             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7603               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7604           else
7605             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7606               {
7607                 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7608                                      TREE_OPERAND (init, 0),
7609                                      build_int_cst (NULL_TREE, i));
7610                 TREE_CONSTANT (fdesc) = 1;
7611
7612                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7613               }
7614         }
7615       else
7616         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7617     }
7618
7619   /* The initializers for virtual functions were built up in reverse
7620      order; straighten them out now.  */
7621   vfun_inits = nreverse (vfun_inits);
7622
7623   /* The negative offset initializers are also in reverse order.  */
7624   vid.inits = nreverse (vid.inits);
7625
7626   /* Chain the two together.  */
7627   return chainon (vid.inits, vfun_inits);
7628 }
7629
7630 /* Adds to vid->inits the initializers for the vbase and vcall
7631    offsets in BINFO, which is in the hierarchy dominated by T.  */
7632
7633 static void
7634 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7635 {
7636   tree b;
7637
7638   /* If this is a derived class, we must first create entries
7639      corresponding to the primary base class.  */
7640   b = get_primary_binfo (binfo);
7641   if (b)
7642     build_vcall_and_vbase_vtbl_entries (b, vid);
7643
7644   /* Add the vbase entries for this base.  */
7645   build_vbase_offset_vtbl_entries (binfo, vid);
7646   /* Add the vcall entries for this base.  */
7647   build_vcall_offset_vtbl_entries (binfo, vid);
7648 }
7649
7650 /* Returns the initializers for the vbase offset entries in the vtable
7651    for BINFO (which is part of the class hierarchy dominated by T), in
7652    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7653    where the next vbase offset will go.  */
7654
7655 static void
7656 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7657 {
7658   tree vbase;
7659   tree t;
7660   tree non_primary_binfo;
7661
7662   /* If there are no virtual baseclasses, then there is nothing to
7663      do.  */
7664   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7665     return;
7666
7667   t = vid->derived;
7668
7669   /* We might be a primary base class.  Go up the inheritance hierarchy
7670      until we find the most derived class of which we are a primary base:
7671      it is the offset of that which we need to use.  */
7672   non_primary_binfo = binfo;
7673   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7674     {
7675       tree b;
7676
7677       /* If we have reached a virtual base, then it must be a primary
7678          base (possibly multi-level) of vid->binfo, or we wouldn't
7679          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7680          might be a lost primary, so just skip down to vid->binfo.  */
7681       if (BINFO_VIRTUAL_P (non_primary_binfo))
7682         {
7683           non_primary_binfo = vid->binfo;
7684           break;
7685         }
7686
7687       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7688       if (get_primary_binfo (b) != non_primary_binfo)
7689         break;
7690       non_primary_binfo = b;
7691     }
7692
7693   /* Go through the virtual bases, adding the offsets.  */
7694   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7695        vbase;
7696        vbase = TREE_CHAIN (vbase))
7697     {
7698       tree b;
7699       tree delta;
7700
7701       if (!BINFO_VIRTUAL_P (vbase))
7702         continue;
7703
7704       /* Find the instance of this virtual base in the complete
7705          object.  */
7706       b = copied_binfo (vbase, binfo);
7707
7708       /* If we've already got an offset for this virtual base, we
7709          don't need another one.  */
7710       if (BINFO_VTABLE_PATH_MARKED (b))
7711         continue;
7712       BINFO_VTABLE_PATH_MARKED (b) = 1;
7713
7714       /* Figure out where we can find this vbase offset.  */
7715       delta = size_binop (MULT_EXPR,
7716                           vid->index,
7717                           convert (ssizetype,
7718                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7719       if (vid->primary_vtbl_p)
7720         BINFO_VPTR_FIELD (b) = delta;
7721
7722       if (binfo != TYPE_BINFO (t))
7723         /* The vbase offset had better be the same.  */
7724         gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
7725
7726       /* The next vbase will come at a more negative offset.  */
7727       vid->index = size_binop (MINUS_EXPR, vid->index,
7728                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7729
7730       /* The initializer is the delta from BINFO to this virtual base.
7731          The vbase offsets go in reverse inheritance-graph order, and
7732          we are walking in inheritance graph order so these end up in
7733          the right order.  */
7734       delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7735
7736       *vid->last_init
7737         = build_tree_list (NULL_TREE,
7738                            fold_build1 (NOP_EXPR,
7739                                         vtable_entry_type,
7740                                         delta));
7741       vid->last_init = &TREE_CHAIN (*vid->last_init);
7742     }
7743 }
7744
7745 /* Adds the initializers for the vcall offset entries in the vtable
7746    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7747    to VID->INITS.  */
7748
7749 static void
7750 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7751 {
7752   /* We only need these entries if this base is a virtual base.  We
7753      compute the indices -- but do not add to the vtable -- when
7754      building the main vtable for a class.  */
7755   if (binfo == TYPE_BINFO (vid->derived)
7756       || (BINFO_VIRTUAL_P (binfo)
7757           /* If BINFO is RTTI_BINFO, then (since BINFO does not
7758              correspond to VID->DERIVED), we are building a primary
7759              construction virtual table.  Since this is a primary
7760              virtual table, we do not need the vcall offsets for
7761              BINFO.  */
7762           && binfo != vid->rtti_binfo))
7763     {
7764       /* We need a vcall offset for each of the virtual functions in this
7765          vtable.  For example:
7766
7767            class A { virtual void f (); };
7768            class B1 : virtual public A { virtual void f (); };
7769            class B2 : virtual public A { virtual void f (); };
7770            class C: public B1, public B2 { virtual void f (); };
7771
7772          A C object has a primary base of B1, which has a primary base of A.  A
7773          C also has a secondary base of B2, which no longer has a primary base
7774          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7775          A, which will adjust the A* to a B2* to call f.  We have no way of
7776          knowing what (or even whether) this offset will be when we define B2,
7777          so we store this "vcall offset" in the A sub-vtable and look it up in
7778          a "virtual thunk" for B2::f.
7779
7780          We need entries for all the functions in our primary vtable and
7781          in our non-virtual bases' secondary vtables.  */
7782       vid->vbase = binfo;
7783       /* If we are just computing the vcall indices -- but do not need
7784          the actual entries -- not that.  */
7785       if (!BINFO_VIRTUAL_P (binfo))
7786         vid->generate_vcall_entries = false;
7787       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7788       add_vcall_offset_vtbl_entries_r (binfo, vid);
7789     }
7790 }
7791
7792 /* Build vcall offsets, starting with those for BINFO.  */
7793
7794 static void
7795 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7796 {
7797   int i;
7798   tree primary_binfo;
7799   tree base_binfo;
7800
7801   /* Don't walk into virtual bases -- except, of course, for the
7802      virtual base for which we are building vcall offsets.  Any
7803      primary virtual base will have already had its offsets generated
7804      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7805   if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
7806     return;
7807
7808   /* If BINFO has a primary base, process it first.  */
7809   primary_binfo = get_primary_binfo (binfo);
7810   if (primary_binfo)
7811     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7812
7813   /* Add BINFO itself to the list.  */
7814   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7815
7816   /* Scan the non-primary bases of BINFO.  */
7817   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7818     if (base_binfo != primary_binfo)
7819       add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7820 }
7821
7822 /* Called from build_vcall_offset_vtbl_entries_r.  */
7823
7824 static void
7825 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7826 {
7827   /* Make entries for the rest of the virtuals.  */
7828   if (abi_version_at_least (2))
7829     {
7830       tree orig_fn;
7831
7832       /* The ABI requires that the methods be processed in declaration
7833          order.  G++ 3.2 used the order in the vtable.  */
7834       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7835            orig_fn;
7836            orig_fn = TREE_CHAIN (orig_fn))
7837         if (DECL_VINDEX (orig_fn))
7838           add_vcall_offset (orig_fn, binfo, vid);
7839     }
7840   else
7841     {
7842       tree derived_virtuals;
7843       tree base_virtuals;
7844       tree orig_virtuals;
7845       /* If BINFO is a primary base, the most derived class which has
7846          BINFO as a primary base; otherwise, just BINFO.  */
7847       tree non_primary_binfo;
7848
7849       /* We might be a primary base class.  Go up the inheritance hierarchy
7850          until we find the most derived class of which we are a primary base:
7851          it is the BINFO_VIRTUALS there that we need to consider.  */
7852       non_primary_binfo = binfo;
7853       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7854         {
7855           tree b;
7856
7857           /* If we have reached a virtual base, then it must be vid->vbase,
7858              because we ignore other virtual bases in
7859              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7860              base (possibly multi-level) of vid->binfo, or we wouldn't
7861              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7862              might be a lost primary, so just skip down to vid->binfo.  */
7863           if (BINFO_VIRTUAL_P (non_primary_binfo))
7864             {
7865               gcc_assert (non_primary_binfo == vid->vbase);
7866               non_primary_binfo = vid->binfo;
7867               break;
7868             }
7869
7870           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7871           if (get_primary_binfo (b) != non_primary_binfo)
7872             break;
7873           non_primary_binfo = b;
7874         }
7875
7876       if (vid->ctor_vtbl_p)
7877         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7878            where rtti_binfo is the most derived type.  */
7879         non_primary_binfo
7880           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7881
7882       for (base_virtuals = BINFO_VIRTUALS (binfo),
7883              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7884              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7885            base_virtuals;
7886            base_virtuals = TREE_CHAIN (base_virtuals),
7887              derived_virtuals = TREE_CHAIN (derived_virtuals),
7888              orig_virtuals = TREE_CHAIN (orig_virtuals))
7889         {
7890           tree orig_fn;
7891
7892           /* Find the declaration that originally caused this function to
7893              be present in BINFO_TYPE (binfo).  */
7894           orig_fn = BV_FN (orig_virtuals);
7895
7896           /* When processing BINFO, we only want to generate vcall slots for
7897              function slots introduced in BINFO.  So don't try to generate
7898              one if the function isn't even defined in BINFO.  */
7899           if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
7900             continue;
7901
7902           add_vcall_offset (orig_fn, binfo, vid);
7903         }
7904     }
7905 }
7906
7907 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7908
7909 static void
7910 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7911 {
7912   size_t i;
7913   tree vcall_offset;
7914   tree derived_entry;
7915
7916   /* If there is already an entry for a function with the same
7917      signature as FN, then we do not need a second vcall offset.
7918      Check the list of functions already present in the derived
7919      class vtable.  */
7920   for (i = 0; VEC_iterate (tree, vid->fns, i, derived_entry); ++i)
7921     {
7922       if (same_signature_p (derived_entry, orig_fn)
7923           /* We only use one vcall offset for virtual destructors,
7924              even though there are two virtual table entries.  */
7925           || (DECL_DESTRUCTOR_P (derived_entry)
7926               && DECL_DESTRUCTOR_P (orig_fn)))
7927         return;
7928     }
7929
7930   /* If we are building these vcall offsets as part of building
7931      the vtable for the most derived class, remember the vcall
7932      offset.  */
7933   if (vid->binfo == TYPE_BINFO (vid->derived))
7934     {
7935       tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
7936                                        CLASSTYPE_VCALL_INDICES (vid->derived),
7937                                        NULL);
7938       elt->purpose = orig_fn;
7939       elt->value = vid->index;
7940     }
7941
7942   /* The next vcall offset will be found at a more negative
7943      offset.  */
7944   vid->index = size_binop (MINUS_EXPR, vid->index,
7945                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7946
7947   /* Keep track of this function.  */
7948   VEC_safe_push (tree, gc, vid->fns, orig_fn);
7949
7950   if (vid->generate_vcall_entries)
7951     {
7952       tree base;
7953       tree fn;
7954
7955       /* Find the overriding function.  */
7956       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7957       if (fn == error_mark_node)
7958         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7959                                integer_zero_node);
7960       else
7961         {
7962           base = TREE_VALUE (fn);
7963
7964           /* The vbase we're working on is a primary base of
7965              vid->binfo.  But it might be a lost primary, so its
7966              BINFO_OFFSET might be wrong, so we just use the
7967              BINFO_OFFSET from vid->binfo.  */
7968           vcall_offset = size_diffop (BINFO_OFFSET (base),
7969                                       BINFO_OFFSET (vid->binfo));
7970           vcall_offset = fold_build1 (NOP_EXPR, vtable_entry_type,
7971                                       vcall_offset);
7972         }
7973       /* Add the initializer to the vtable.  */
7974       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7975       vid->last_init = &TREE_CHAIN (*vid->last_init);
7976     }
7977 }
7978
7979 /* Return vtbl initializers for the RTTI entries corresponding to the
7980    BINFO's vtable.  The RTTI entries should indicate the object given
7981    by VID->rtti_binfo.  */
7982
7983 static void
7984 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7985 {
7986   tree b;
7987   tree t;
7988   tree basetype;
7989   tree offset;
7990   tree decl;
7991   tree init;
7992
7993   basetype = BINFO_TYPE (binfo);
7994   t = BINFO_TYPE (vid->rtti_binfo);
7995
7996   /* To find the complete object, we will first convert to our most
7997      primary base, and then add the offset in the vtbl to that value.  */
7998   b = binfo;
7999   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
8000          && !BINFO_LOST_PRIMARY_P (b))
8001     {
8002       tree primary_base;
8003
8004       primary_base = get_primary_binfo (b);
8005       gcc_assert (BINFO_PRIMARY_P (primary_base)
8006                   && BINFO_INHERITANCE_CHAIN (primary_base) == b);
8007       b = primary_base;
8008     }
8009   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
8010
8011   /* The second entry is the address of the typeinfo object.  */
8012   if (flag_rtti)
8013     decl = build_address (get_tinfo_decl (t));
8014   else
8015     decl = integer_zero_node;
8016
8017   /* Convert the declaration to a type that can be stored in the
8018      vtable.  */
8019   init = build_nop (vfunc_ptr_type_node, decl);
8020   *vid->last_init = build_tree_list (NULL_TREE, init);
8021   vid->last_init = &TREE_CHAIN (*vid->last_init);
8022
8023   /* Add the offset-to-top entry.  It comes earlier in the vtable than
8024      the typeinfo entry.  Convert the offset to look like a
8025      function pointer, so that we can put it in the vtable.  */
8026   init = build_nop (vfunc_ptr_type_node, offset);
8027   *vid->last_init = build_tree_list (NULL_TREE, init);
8028   vid->last_init = &TREE_CHAIN (*vid->last_init);
8029 }
8030
8031 /* Fold a OBJ_TYPE_REF expression to the address of a function.
8032    KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF).  */
8033
8034 tree
8035 cp_fold_obj_type_ref (tree ref, tree known_type)
8036 {
8037   HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
8038   HOST_WIDE_INT i = 0;
8039   tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
8040   tree fndecl;
8041
8042   while (i != index)
8043     {
8044       i += (TARGET_VTABLE_USES_DESCRIPTORS
8045             ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
8046       v = TREE_CHAIN (v);
8047     }
8048
8049   fndecl = BV_FN (v);
8050
8051 #ifdef ENABLE_CHECKING
8052   gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
8053                                   DECL_VINDEX (fndecl)));
8054 #endif
8055
8056   cgraph_node (fndecl)->local.vtable_method = true;
8057
8058   return build_address (fndecl);
8059 }
8060
8061 #include "gt-cp-class.h"