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