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