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