gcc/cp/class.c

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