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