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