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