gcc/cp/class.c

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