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