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