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