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