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