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 /* Returns true iff class T has a user-defined constructor other than
4043    the default constructor.  */
4044
4045 bool
4046 type_has_user_nondefault_constructor (tree t)
4047 {
4048   tree fns;
4049
4050   if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4051     return false;
4052
4053   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4054     {
4055       tree fn = OVL_CURRENT (fns);
4056       if (!DECL_ARTIFICIAL (fn)
4057           && skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn)) != NULL_TREE)
4058         return true;
4059     }
4060
4061   return false;
4062 }
4063
4064 /* Remove all zero-width bit-fields from T.  */
4065
4066 static void
4067 remove_zero_width_bit_fields (tree t)
4068 {
4069   tree *fieldsp;
4070
4071   fieldsp = &TYPE_FIELDS (t);
4072   while (*fieldsp)
4073     {
4074       if (TREE_CODE (*fieldsp) == FIELD_DECL
4075           && DECL_C_BIT_FIELD (*fieldsp)
4076           && DECL_INITIAL (*fieldsp))
4077         *fieldsp = TREE_CHAIN (*fieldsp);
4078       else
4079         fieldsp = &TREE_CHAIN (*fieldsp);
4080     }
4081 }
4082
4083 /* Returns TRUE iff we need a cookie when dynamically allocating an
4084    array whose elements have the indicated class TYPE.  */
4085
4086 static bool
4087 type_requires_array_cookie (tree type)
4088 {
4089   tree fns;
4090   bool has_two_argument_delete_p = false;
4091
4092   gcc_assert (CLASS_TYPE_P (type));
4093
4094   /* If there's a non-trivial destructor, we need a cookie.  In order
4095      to iterate through the array calling the destructor for each
4096      element, we'll have to know how many elements there are.  */
4097   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4098     return true;
4099
4100   /* If the usual deallocation function is a two-argument whose second
4101      argument is of type `size_t', then we have to pass the size of
4102      the array to the deallocation function, so we will need to store
4103      a cookie.  */
4104   fns = lookup_fnfields (TYPE_BINFO (type),
4105                          ansi_opname (VEC_DELETE_EXPR),
4106                          /*protect=*/0);
4107   /* If there are no `operator []' members, or the lookup is
4108      ambiguous, then we don't need a cookie.  */
4109   if (!fns || fns == error_mark_node)
4110     return false;
4111   /* Loop through all of the functions.  */
4112   for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4113     {
4114       tree fn;
4115       tree second_parm;
4116
4117       /* Select the current function.  */
4118       fn = OVL_CURRENT (fns);
4119       /* See if this function is a one-argument delete function.  If
4120          it is, then it will be the usual deallocation function.  */
4121       second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4122       if (second_parm == void_list_node)
4123         return false;
4124       /* Otherwise, if we have a two-argument function and the second
4125          argument is `size_t', it will be the usual deallocation
4126          function -- unless there is one-argument function, too.  */
4127       if (TREE_CHAIN (second_parm) == void_list_node
4128           && same_type_p (TREE_VALUE (second_parm), size_type_node))
4129         has_two_argument_delete_p = true;
4130     }
4131
4132   return has_two_argument_delete_p;
4133 }
4134
4135 /* Check the validity of the bases and members declared in T.  Add any
4136    implicitly-generated functions (like copy-constructors and
4137    assignment operators).  Compute various flag bits (like
4138    CLASSTYPE_NON_POD_T) for T.  This routine works purely at the C++
4139    level: i.e., independently of the ABI in use.  */
4140
4141 static void
4142 check_bases_and_members (tree t)
4143 {
4144   /* Nonzero if the implicitly generated copy constructor should take
4145      a non-const reference argument.  */
4146   int cant_have_const_ctor;
4147   /* Nonzero if the implicitly generated assignment operator
4148      should take a non-const reference argument.  */
4149   int no_const_asn_ref;
4150   tree access_decls;
4151
4152   /* By default, we use const reference arguments and generate default
4153      constructors.  */
4154   cant_have_const_ctor = 0;
4155   no_const_asn_ref = 0;
4156
4157   /* Check all the base-classes.  */
4158   check_bases (t, &cant_have_const_ctor,
4159                &no_const_asn_ref);
4160
4161   /* Check all the method declarations.  */
4162   check_methods (t);
4163
4164   /* Check all the data member declarations.  We cannot call
4165      check_field_decls until we have called check_bases check_methods,
4166      as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4167      being set appropriately.  */
4168   check_field_decls (t, &access_decls,
4169                      &cant_have_const_ctor,
4170                      &no_const_asn_ref);
4171
4172   /* A nearly-empty class has to be vptr-containing; a nearly empty
4173      class contains just a vptr.  */
4174   if (!TYPE_CONTAINS_VPTR_P (t))
4175     CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4176
4177   /* Do some bookkeeping that will guide the generation of implicitly
4178      declared member functions.  */
4179   TYPE_HAS_COMPLEX_INIT_REF (t)
4180     |= (TYPE_HAS_INIT_REF (t) || TYPE_CONTAINS_VPTR_P (t));
4181   /* We need to call a constructor for this class if it has a
4182      user-declared constructor, or if the default constructor is going
4183      to initialize the vptr.  (This is not an if-and-only-if;
4184      TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
4185      themselves need constructing.)  */
4186   TYPE_NEEDS_CONSTRUCTING (t)
4187     |= (TYPE_HAS_USER_CONSTRUCTOR (t) || TYPE_CONTAINS_VPTR_P (t));
4188   /* [dcl.init.aggr]
4189
4190      An aggregate is an arry or a class with no user-declared
4191      constructors ... and no virtual functions.
4192
4193      Again, other conditions for being an aggregate are checked
4194      elsewhere.  */
4195   CLASSTYPE_NON_AGGREGATE (t)
4196     |= (TYPE_HAS_USER_CONSTRUCTOR (t) || TYPE_POLYMORPHIC_P (t));
4197   CLASSTYPE_NON_POD_P (t)
4198     |= (CLASSTYPE_NON_AGGREGATE (t)
4199         || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
4200         || TYPE_HAS_ASSIGN_REF (t));
4201   TYPE_HAS_COMPLEX_ASSIGN_REF (t)
4202     |= TYPE_HAS_ASSIGN_REF (t) || TYPE_CONTAINS_VPTR_P (t);
4203   TYPE_HAS_COMPLEX_DFLT (t)
4204     |= (TYPE_HAS_DEFAULT_CONSTRUCTOR (t) || TYPE_CONTAINS_VPTR_P (t));
4205
4206   /* If the class has no user-declared constructor, but does have
4207      non-static const or reference data members that can never be
4208      initialized, issue a warning.  */
4209   if (extra_warnings
4210       /* Classes with user-declared constructors are presumed to
4211          initialize these members.  */
4212       && !TYPE_HAS_USER_CONSTRUCTOR (t)
4213       /* Aggregates can be initialized with brace-enclosed
4214          initializers.  */
4215       && CLASSTYPE_NON_AGGREGATE (t))
4216     {
4217       tree field;
4218
4219       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4220         {
4221           tree type;
4222
4223           if (TREE_CODE (field) != FIELD_DECL)
4224             continue;
4225
4226           type = TREE_TYPE (field);
4227           if (TREE_CODE (type) == REFERENCE_TYPE)
4228             warning (OPT_Wextra, "non-static reference %q+#D in class "
4229                      "without a constructor", field);
4230           else if (CP_TYPE_CONST_P (type)
4231                    && (!CLASS_TYPE_P (type)
4232                        || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4233             warning (OPT_Wextra, "non-static const member %q+#D in class "
4234                      "without a constructor", field);
4235         }
4236     }
4237
4238   /* Synthesize any needed methods.  */
4239   add_implicitly_declared_members (t,
4240                                    cant_have_const_ctor,
4241                                    no_const_asn_ref);
4242
4243   /* Create the in-charge and not-in-charge variants of constructors
4244      and destructors.  */
4245   clone_constructors_and_destructors (t);
4246
4247   /* Process the using-declarations.  */
4248   for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4249     handle_using_decl (TREE_VALUE (access_decls), t);
4250
4251   /* Build and sort the CLASSTYPE_METHOD_VEC.  */
4252   finish_struct_methods (t);
4253
4254   /* Figure out whether or not we will need a cookie when dynamically
4255      allocating an array of this type.  */
4256   TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4257     = type_requires_array_cookie (t);
4258 }
4259
4260 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4261    accordingly.  If a new vfield was created (because T doesn't have a
4262    primary base class), then the newly created field is returned.  It
4263    is not added to the TYPE_FIELDS list; it is the caller's
4264    responsibility to do that.  Accumulate declared virtual functions
4265    on VIRTUALS_P.  */
4266
4267 static tree
4268 create_vtable_ptr (tree t, tree* virtuals_p)
4269 {
4270   tree fn;
4271
4272   /* Collect the virtual functions declared in T.  */
4273   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4274     if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4275         && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4276       {
4277         tree new_virtual = make_node (TREE_LIST);
4278
4279         BV_FN (new_virtual) = fn;
4280         BV_DELTA (new_virtual) = integer_zero_node;
4281         BV_VCALL_INDEX (new_virtual) = NULL_TREE;
4282
4283         TREE_CHAIN (new_virtual) = *virtuals_p;
4284         *virtuals_p = new_virtual;
4285       }
4286
4287   /* If we couldn't find an appropriate base class, create a new field
4288      here.  Even if there weren't any new virtual functions, we might need a
4289      new virtual function table if we're supposed to include vptrs in
4290      all classes that need them.  */
4291   if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4292     {
4293       /* We build this decl with vtbl_ptr_type_node, which is a
4294          `vtable_entry_type*'.  It might seem more precise to use
4295          `vtable_entry_type (*)[N]' where N is the number of virtual
4296          functions.  However, that would require the vtable pointer in
4297          base classes to have a different type than the vtable pointer
4298          in derived classes.  We could make that happen, but that
4299          still wouldn't solve all the problems.  In particular, the
4300          type-based alias analysis code would decide that assignments
4301          to the base class vtable pointer can't alias assignments to
4302          the derived class vtable pointer, since they have different
4303          types.  Thus, in a derived class destructor, where the base
4304          class constructor was inlined, we could generate bad code for
4305          setting up the vtable pointer.
4306
4307          Therefore, we use one type for all vtable pointers.  We still
4308          use a type-correct type; it's just doesn't indicate the array
4309          bounds.  That's better than using `void*' or some such; it's
4310          cleaner, and it let's the alias analysis code know that these
4311          stores cannot alias stores to void*!  */
4312       tree field;
4313
4314       field = build_decl (FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4315       DECL_VIRTUAL_P (field) = 1;
4316       DECL_ARTIFICIAL (field) = 1;
4317       DECL_FIELD_CONTEXT (field) = t;
4318       DECL_FCONTEXT (field) = t;
4319
4320       TYPE_VFIELD (t) = field;
4321
4322       /* This class is non-empty.  */
4323       CLASSTYPE_EMPTY_P (t) = 0;
4324
4325       return field;
4326     }
4327
4328   return NULL_TREE;
4329 }
4330
4331 /* Fixup the inline function given by INFO now that the class is
4332    complete.  */
4333
4334 static void
4335 fixup_pending_inline (tree fn)
4336 {
4337   if (DECL_PENDING_INLINE_INFO (fn))
4338     {
4339       tree args = DECL_ARGUMENTS (fn);
4340       while (args)
4341         {
4342           DECL_CONTEXT (args) = fn;
4343           args = TREE_CHAIN (args);
4344         }
4345     }
4346 }
4347
4348 /* Fixup the inline methods and friends in TYPE now that TYPE is
4349    complete.  */
4350
4351 static void
4352 fixup_inline_methods (tree type)
4353 {
4354   tree method = TYPE_METHODS (type);
4355   VEC(tree,gc) *friends;
4356   unsigned ix;
4357
4358   if (method && TREE_CODE (method) == TREE_VEC)
4359     {
4360       if (TREE_VEC_ELT (method, 1))
4361         method = TREE_VEC_ELT (method, 1);
4362       else if (TREE_VEC_ELT (method, 0))
4363         method = TREE_VEC_ELT (method, 0);
4364       else
4365         method = TREE_VEC_ELT (method, 2);
4366     }
4367
4368   /* Do inline member functions.  */
4369   for (; method; method = TREE_CHAIN (method))
4370     fixup_pending_inline (method);
4371
4372   /* Do friends.  */
4373   for (friends = CLASSTYPE_INLINE_FRIENDS (type), ix = 0;
4374        VEC_iterate (tree, friends, ix, method); ix++)
4375     fixup_pending_inline (method);
4376   CLASSTYPE_INLINE_FRIENDS (type) = NULL;
4377 }
4378
4379 /* Add OFFSET to all base types of BINFO which is a base in the
4380    hierarchy dominated by T.
4381
4382    OFFSET, which is a type offset, is number of bytes.  */
4383
4384 static void
4385 propagate_binfo_offsets (tree binfo, tree offset)
4386 {
4387   int i;
4388   tree primary_binfo;
4389   tree base_binfo;
4390
4391   /* Update BINFO's offset.  */
4392   BINFO_OFFSET (binfo)
4393     = convert (sizetype,
4394                size_binop (PLUS_EXPR,
4395                            convert (ssizetype, BINFO_OFFSET (binfo)),
4396                            offset));
4397
4398   /* Find the primary base class.  */
4399   primary_binfo = get_primary_binfo (binfo);
4400
4401   if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo)
4402     propagate_binfo_offsets (primary_binfo, offset);
4403
4404   /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4405      downwards.  */
4406   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4407     {
4408       /* Don't do the primary base twice.  */
4409       if (base_binfo == primary_binfo)
4410         continue;
4411
4412       if (BINFO_VIRTUAL_P (base_binfo))
4413         continue;
4414
4415       propagate_binfo_offsets (base_binfo, offset);
4416     }
4417 }
4418
4419 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T.  Update
4420    TYPE_ALIGN and TYPE_SIZE for T.  OFFSETS gives the location of
4421    empty subobjects of T.  */
4422
4423 static void
4424 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4425 {
4426   tree vbase;
4427   tree t = rli->t;
4428   bool first_vbase = true;
4429   tree *next_field;
4430
4431   if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0)
4432     return;
4433
4434   if (!abi_version_at_least(2))
4435     {
4436       /* In G++ 3.2, we incorrectly rounded the size before laying out
4437          the virtual bases.  */
4438       finish_record_layout (rli, /*free_p=*/false);
4439 #ifdef STRUCTURE_SIZE_BOUNDARY
4440       /* Packed structures don't need to have minimum size.  */
4441       if (! TYPE_PACKED (t))
4442         TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
4443 #endif
4444       rli->offset = TYPE_SIZE_UNIT (t);
4445       rli->bitpos = bitsize_zero_node;
4446       rli->record_align = TYPE_ALIGN (t);
4447     }
4448
4449   /* Find the last field.  The artificial fields created for virtual
4450      bases will go after the last extant field to date.  */
4451   next_field = &TYPE_FIELDS (t);
4452   while (*next_field)
4453     next_field = &TREE_CHAIN (*next_field);
4454
4455   /* Go through the virtual bases, allocating space for each virtual
4456      base that is not already a primary base class.  These are
4457      allocated in inheritance graph order.  */
4458   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
4459     {
4460       if (!BINFO_VIRTUAL_P (vbase))
4461         continue;
4462
4463       if (!BINFO_PRIMARY_P (vbase))
4464         {
4465           tree basetype = TREE_TYPE (vbase);
4466
4467           /* This virtual base is not a primary base of any class in the
4468              hierarchy, so we have to add space for it.  */
4469           next_field = build_base_field (rli, vbase,
4470                                          offsets, next_field);
4471
4472           /* If the first virtual base might have been placed at a
4473              lower address, had we started from CLASSTYPE_SIZE, rather
4474              than TYPE_SIZE, issue a warning.  There can be both false
4475              positives and false negatives from this warning in rare
4476              cases; to deal with all the possibilities would probably
4477              require performing both layout algorithms and comparing
4478              the results which is not particularly tractable.  */
4479           if (warn_abi
4480               && first_vbase
4481               && (tree_int_cst_lt
4482                   (size_binop (CEIL_DIV_EXPR,
4483                                round_up (CLASSTYPE_SIZE (t),
4484                                          CLASSTYPE_ALIGN (basetype)),
4485                                bitsize_unit_node),
4486                    BINFO_OFFSET (vbase))))
4487             warning (OPT_Wabi,
4488                      "offset of virtual base %qT is not ABI-compliant and "
4489                      "may change in a future version of GCC",
4490                      basetype);
4491
4492           first_vbase = false;
4493         }
4494     }
4495 }
4496
4497 /* Returns the offset of the byte just past the end of the base class
4498    BINFO.  */
4499
4500 static tree
4501 end_of_base (tree binfo)
4502 {
4503   tree size;
4504
4505   if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo)))
4506     size = TYPE_SIZE_UNIT (char_type_node);
4507   else if (is_empty_class (BINFO_TYPE (binfo)))
4508     /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4509        allocate some space for it. It cannot have virtual bases, so
4510        TYPE_SIZE_UNIT is fine.  */
4511     size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4512   else
4513     size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4514
4515   return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
4516 }
4517
4518 /* Returns the offset of the byte just past the end of the base class
4519    with the highest offset in T.  If INCLUDE_VIRTUALS_P is zero, then
4520    only non-virtual bases are included.  */
4521
4522 static tree
4523 end_of_class (tree t, int include_virtuals_p)
4524 {
4525   tree result = size_zero_node;
4526   VEC(tree,gc) *vbases;
4527   tree binfo;
4528   tree base_binfo;
4529   tree offset;
4530   int i;
4531
4532   for (binfo = TYPE_BINFO (t), i = 0;
4533        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4534     {
4535       if (!include_virtuals_p
4536           && BINFO_VIRTUAL_P (base_binfo)
4537           && (!BINFO_PRIMARY_P (base_binfo)
4538               || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t)))
4539         continue;
4540
4541       offset = end_of_base (base_binfo);
4542       if (INT_CST_LT_UNSIGNED (result, offset))
4543         result = offset;
4544     }
4545
4546   /* G++ 3.2 did not check indirect virtual bases.  */
4547   if (abi_version_at_least (2) && include_virtuals_p)
4548     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4549          VEC_iterate (tree, vbases, i, base_binfo); i++)
4550       {
4551         offset = end_of_base (base_binfo);
4552         if (INT_CST_LT_UNSIGNED (result, offset))
4553           result = offset;
4554       }
4555
4556   return result;
4557 }
4558
4559 /* Warn about bases of T that are inaccessible because they are
4560    ambiguous.  For example:
4561
4562      struct S {};
4563      struct T : public S {};
4564      struct U : public S, public T {};
4565
4566    Here, `(S*) new U' is not allowed because there are two `S'
4567    subobjects of U.  */
4568
4569 static void
4570 warn_about_ambiguous_bases (tree t)
4571 {
4572   int i;
4573   VEC(tree,gc) *vbases;
4574   tree basetype;
4575   tree binfo;
4576   tree base_binfo;
4577
4578   /* If there are no repeated bases, nothing can be ambiguous.  */
4579   if (!CLASSTYPE_REPEATED_BASE_P (t))
4580     return;
4581
4582   /* Check direct bases.  */
4583   for (binfo = TYPE_BINFO (t), i = 0;
4584        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4585     {
4586       basetype = BINFO_TYPE (base_binfo);
4587
4588       if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
4589         warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
4590                  basetype, t);
4591     }
4592
4593   /* Check for ambiguous virtual bases.  */
4594   if (extra_warnings)
4595     for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4596          VEC_iterate (tree, vbases, i, binfo); i++)
4597       {
4598         basetype = BINFO_TYPE (binfo);
4599
4600         if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
4601           warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due to ambiguity",
4602                    basetype, t);
4603       }
4604 }
4605
4606 /* Compare two INTEGER_CSTs K1 and K2.  */
4607
4608 static int
4609 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
4610 {
4611   return tree_int_cst_compare ((tree) k1, (tree) k2);
4612 }
4613
4614 /* Increase the size indicated in RLI to account for empty classes
4615    that are "off the end" of the class.  */
4616
4617 static void
4618 include_empty_classes (record_layout_info rli)
4619 {
4620   tree eoc;
4621   tree rli_size;
4622
4623   /* It might be the case that we grew the class to allocate a
4624      zero-sized base class.  That won't be reflected in RLI, yet,
4625      because we are willing to overlay multiple bases at the same
4626      offset.  However, now we need to make sure that RLI is big enough
4627      to reflect the entire class.  */
4628   eoc = end_of_class (rli->t,
4629                       CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
4630   rli_size = rli_size_unit_so_far (rli);
4631   if (TREE_CODE (rli_size) == INTEGER_CST
4632       && INT_CST_LT_UNSIGNED (rli_size, eoc))
4633     {
4634       if (!abi_version_at_least (2))
4635         /* In version 1 of the ABI, the size of a class that ends with
4636            a bitfield was not rounded up to a whole multiple of a
4637            byte.  Because rli_size_unit_so_far returns only the number
4638            of fully allocated bytes, any extra bits were not included
4639            in the size.  */
4640         rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
4641       else
4642         /* The size should have been rounded to a whole byte.  */
4643         gcc_assert (tree_int_cst_equal
4644                     (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT)));
4645       rli->bitpos
4646         = size_binop (PLUS_EXPR,
4647                       rli->bitpos,
4648                       size_binop (MULT_EXPR,
4649                                   convert (bitsizetype,
4650                                            size_binop (MINUS_EXPR,
4651                                                        eoc, rli_size)),
4652                                   bitsize_int (BITS_PER_UNIT)));
4653       normalize_rli (rli);
4654     }
4655 }
4656
4657 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T.  Calculate
4658    BINFO_OFFSETs for all of the base-classes.  Position the vtable
4659    pointer.  Accumulate declared virtual functions on VIRTUALS_P.  */
4660
4661 static void
4662 layout_class_type (tree t, tree *virtuals_p)
4663 {
4664   tree non_static_data_members;
4665   tree field;
4666   tree vptr;
4667   record_layout_info rli;
4668   /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4669      types that appear at that offset.  */
4670   splay_tree empty_base_offsets;
4671   /* True if the last field layed out was a bit-field.  */
4672   bool last_field_was_bitfield = false;
4673   /* The location at which the next field should be inserted.  */
4674   tree *next_field;
4675   /* T, as a base class.  */
4676   tree base_t;
4677
4678   /* Keep track of the first non-static data member.  */
4679   non_static_data_members = TYPE_FIELDS (t);
4680
4681   /* Start laying out the record.  */
4682   rli = start_record_layout (t);
4683
4684   /* Mark all the primary bases in the hierarchy.  */
4685   determine_primary_bases (t);
4686
4687   /* Create a pointer to our virtual function table.  */
4688   vptr = create_vtable_ptr (t, virtuals_p);
4689
4690   /* The vptr is always the first thing in the class.  */
4691   if (vptr)
4692     {
4693       TREE_CHAIN (vptr) = TYPE_FIELDS (t);
4694       TYPE_FIELDS (t) = vptr;
4695       next_field = &TREE_CHAIN (vptr);
4696       place_field (rli, vptr);
4697     }
4698   else
4699     next_field = &TYPE_FIELDS (t);
4700
4701   /* Build FIELD_DECLs for all of the non-virtual base-types.  */
4702   empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
4703                                        NULL, NULL);
4704   build_base_fields (rli, empty_base_offsets, next_field);
4705
4706   /* Layout the non-static data members.  */
4707   for (field = non_static_data_members; field; field = TREE_CHAIN (field))
4708     {
4709       tree type;
4710       tree padding;
4711
4712       /* We still pass things that aren't non-static data members to
4713          the back end, in case it wants to do something with them.  */
4714       if (TREE_CODE (field) != FIELD_DECL)
4715         {
4716           place_field (rli, field);
4717           /* If the static data member has incomplete type, keep track
4718              of it so that it can be completed later.  (The handling
4719              of pending statics in finish_record_layout is
4720              insufficient; consider:
4721
4722                struct S1;
4723                struct S2 { static S1 s1; };
4724
4725              At this point, finish_record_layout will be called, but
4726              S1 is still incomplete.)  */
4727           if (TREE_CODE (field) == VAR_DECL)
4728             {
4729               maybe_register_incomplete_var (field);
4730               /* The visibility of static data members is determined
4731                  at their point of declaration, not their point of
4732                  definition.  */
4733               determine_visibility (field);
4734             }
4735           continue;
4736         }
4737
4738       type = TREE_TYPE (field);
4739       if (type == error_mark_node)
4740         continue;
4741
4742       padding = NULL_TREE;
4743
4744       /* If this field is a bit-field whose width is greater than its
4745          type, then there are some special rules for allocating
4746          it.  */
4747       if (DECL_C_BIT_FIELD (field)
4748           && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
4749         {
4750           integer_type_kind itk;
4751           tree integer_type;
4752           bool was_unnamed_p = false;
4753           /* We must allocate the bits as if suitably aligned for the
4754              longest integer type that fits in this many bits.  type
4755              of the field.  Then, we are supposed to use the left over
4756              bits as additional padding.  */
4757           for (itk = itk_char; itk != itk_none; ++itk)
4758             if (INT_CST_LT (DECL_SIZE (field),
4759                             TYPE_SIZE (integer_types[itk])))
4760               break;
4761
4762           /* ITK now indicates a type that is too large for the
4763              field.  We have to back up by one to find the largest
4764              type that fits.  */
4765           integer_type = integer_types[itk - 1];
4766
4767           /* Figure out how much additional padding is required.  GCC
4768              3.2 always created a padding field, even if it had zero
4769              width.  */
4770           if (!abi_version_at_least (2)
4771               || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
4772             {
4773               if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
4774                 /* In a union, the padding field must have the full width
4775                    of the bit-field; all fields start at offset zero.  */
4776                 padding = DECL_SIZE (field);
4777               else
4778                 {
4779                   if (TREE_CODE (t) == UNION_TYPE)
4780                     warning (OPT_Wabi, "size assigned to %qT may not be "
4781                              "ABI-compliant and may change in a future "
4782                              "version of GCC",
4783                              t);
4784                   padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
4785                                         TYPE_SIZE (integer_type));
4786                 }
4787             }
4788 #ifdef PCC_BITFIELD_TYPE_MATTERS
4789           /* An unnamed bitfield does not normally affect the
4790              alignment of the containing class on a target where
4791              PCC_BITFIELD_TYPE_MATTERS.  But, the C++ ABI does not
4792              make any exceptions for unnamed bitfields when the
4793              bitfields are longer than their types.  Therefore, we
4794              temporarily give the field a name.  */
4795           if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
4796             {
4797               was_unnamed_p = true;
4798               DECL_NAME (field) = make_anon_name ();
4799             }
4800 #endif
4801           DECL_SIZE (field) = TYPE_SIZE (integer_type);
4802           DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
4803           DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
4804           layout_nonempty_base_or_field (rli, field, NULL_TREE,
4805                                          empty_base_offsets);
4806           if (was_unnamed_p)
4807             DECL_NAME (field) = NULL_TREE;
4808           /* Now that layout has been performed, set the size of the
4809              field to the size of its declared type; the rest of the
4810              field is effectively invisible.  */
4811           DECL_SIZE (field) = TYPE_SIZE (type);
4812           /* We must also reset the DECL_MODE of the field.  */
4813           if (abi_version_at_least (2))
4814             DECL_MODE (field) = TYPE_MODE (type);
4815           else if (warn_abi
4816                    && DECL_MODE (field) != TYPE_MODE (type))
4817             /* Versions of G++ before G++ 3.4 did not reset the
4818                DECL_MODE.  */
4819             warning (OPT_Wabi,
4820                      "the offset of %qD may not be ABI-compliant and may "
4821                      "change in a future version of GCC", field);
4822         }
4823       else
4824         layout_nonempty_base_or_field (rli, field, NULL_TREE,
4825                                        empty_base_offsets);
4826
4827       /* Remember the location of any empty classes in FIELD.  */
4828       if (abi_version_at_least (2))
4829         record_subobject_offsets (TREE_TYPE (field),
4830                                   byte_position(field),
4831                                   empty_base_offsets,
4832                                   /*is_data_member=*/true);
4833
4834       /* If a bit-field does not immediately follow another bit-field,
4835          and yet it starts in the middle of a byte, we have failed to
4836          comply with the ABI.  */
4837       if (warn_abi
4838           && DECL_C_BIT_FIELD (field)
4839           /* The TREE_NO_WARNING flag gets set by Objective-C when
4840              laying out an Objective-C class.  The ObjC ABI differs
4841              from the C++ ABI, and so we do not want a warning
4842              here.  */
4843           && !TREE_NO_WARNING (field)
4844           && !last_field_was_bitfield
4845           && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
4846                                          DECL_FIELD_BIT_OFFSET (field),
4847                                          bitsize_unit_node)))
4848         warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may "
4849                  "change in a future version of GCC", field);
4850
4851       /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4852          offset of the field.  */
4853       if (warn_abi
4854           && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
4855                                   byte_position (field))
4856           && contains_empty_class_p (TREE_TYPE (field)))
4857         warning (OPT_Wabi, "%q+D contains empty classes which may cause base "
4858                  "classes to be placed at different locations in a "
4859                  "future version of GCC", field);
4860
4861       /* The middle end uses the type of expressions to determine the
4862          possible range of expression values.  In order to optimize
4863          "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
4864          must be made aware of the width of "i", via its type.
4865
4866          Because C++ does not have integer types of arbitrary width,
4867          we must (for the purposes of the front end) convert from the
4868          type assigned here to the declared type of the bitfield
4869          whenever a bitfield expression is used as an rvalue.
4870          Similarly, when assigning a value to a bitfield, the value
4871          must be converted to the type given the bitfield here.  */
4872       if (DECL_C_BIT_FIELD (field))
4873         {
4874           unsigned HOST_WIDE_INT width;
4875           tree ftype = TREE_TYPE (field);
4876           width = tree_low_cst (DECL_SIZE (field), /*unsignedp=*/1);
4877           if (width != TYPE_PRECISION (ftype))
4878             {
4879               TREE_TYPE (field)
4880                 = c_build_bitfield_integer_type (width,
4881                                                  TYPE_UNSIGNED (ftype));
4882               TREE_TYPE (field)
4883                 = cp_build_qualified_type (TREE_TYPE (field),
4884                                            TYPE_QUALS (ftype));
4885             }
4886         }
4887
4888       /* If we needed additional padding after this field, add it
4889          now.  */
4890       if (padding)
4891         {
4892           tree padding_field;
4893
4894           padding_field = build_decl (FIELD_DECL,
4895                                       NULL_TREE,
4896                                       char_type_node);
4897           DECL_BIT_FIELD (padding_field) = 1;
4898           DECL_SIZE (padding_field) = padding;
4899           DECL_CONTEXT (padding_field) = t;
4900           DECL_ARTIFICIAL (padding_field) = 1;
4901           DECL_IGNORED_P (padding_field) = 1;
4902           layout_nonempty_base_or_field (rli, padding_field,
4903                                          NULL_TREE,
4904                                          empty_base_offsets);
4905         }
4906
4907       last_field_was_bitfield = DECL_C_BIT_FIELD (field);
4908     }
4909
4910   if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
4911     {
4912       /* Make sure that we are on a byte boundary so that the size of
4913          the class without virtual bases will always be a round number
4914          of bytes.  */
4915       rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT);
4916       normalize_rli (rli);
4917     }
4918
4919   /* G++ 3.2 does not allow virtual bases to be overlaid with tail
4920      padding.  */
4921   if (!abi_version_at_least (2))
4922     include_empty_classes(rli);
4923
4924   /* Delete all zero-width bit-fields from the list of fields.  Now
4925      that the type is laid out they are no longer important.  */
4926   remove_zero_width_bit_fields (t);
4927
4928   /* Create the version of T used for virtual bases.  We do not use
4929      make_aggr_type for this version; this is an artificial type.  For
4930      a POD type, we just reuse T.  */
4931   if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t))
4932     {
4933       base_t = make_node (TREE_CODE (t));
4934
4935       /* Set the size and alignment for the new type.  In G++ 3.2, all
4936          empty classes were considered to have size zero when used as
4937          base classes.  */
4938       if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
4939         {
4940           TYPE_SIZE (base_t) = bitsize_zero_node;
4941           TYPE_SIZE_UNIT (base_t) = size_zero_node;
4942           if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
4943             warning (OPT_Wabi,
4944                      "layout of classes derived from empty class %qT "
4945                      "may change in a future version of GCC",
4946                      t);
4947         }
4948       else
4949         {
4950           tree eoc;
4951
4952           /* If the ABI version is not at least two, and the last
4953              field was a bit-field, RLI may not be on a byte
4954              boundary.  In particular, rli_size_unit_so_far might
4955              indicate the last complete byte, while rli_size_so_far
4956              indicates the total number of bits used.  Therefore,
4957              rli_size_so_far, rather than rli_size_unit_so_far, is
4958              used to compute TYPE_SIZE_UNIT.  */
4959           eoc = end_of_class (t, /*include_virtuals_p=*/0);
4960           TYPE_SIZE_UNIT (base_t)
4961             = size_binop (MAX_EXPR,
4962                           convert (sizetype,
4963                                    size_binop (CEIL_DIV_EXPR,
4964                                                rli_size_so_far (rli),
4965                                                bitsize_int (BITS_PER_UNIT))),
4966                           eoc);
4967           TYPE_SIZE (base_t)
4968             = size_binop (MAX_EXPR,
4969                           rli_size_so_far (rli),
4970                           size_binop (MULT_EXPR,
4971                                       convert (bitsizetype, eoc),
4972                                       bitsize_int (BITS_PER_UNIT)));
4973         }
4974       TYPE_ALIGN (base_t) = rli->record_align;
4975       TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
4976
4977       /* Copy the fields from T.  */
4978       next_field = &TYPE_FIELDS (base_t);
4979       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4980         if (TREE_CODE (field) == FIELD_DECL)
4981           {
4982             *next_field = build_decl (FIELD_DECL,
4983                                       DECL_NAME (field),
4984                                       TREE_TYPE (field));
4985             DECL_CONTEXT (*next_field) = base_t;
4986             DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
4987             DECL_FIELD_BIT_OFFSET (*next_field)
4988               = DECL_FIELD_BIT_OFFSET (field);
4989             DECL_SIZE (*next_field) = DECL_SIZE (field);
4990             DECL_MODE (*next_field) = DECL_MODE (field);
4991             next_field = &TREE_CHAIN (*next_field);
4992           }
4993
4994       /* Record the base version of the type.  */
4995       CLASSTYPE_AS_BASE (t) = base_t;
4996       TYPE_CONTEXT (base_t) = t;
4997     }
4998   else
4999     CLASSTYPE_AS_BASE (t) = t;
5000
5001   /* Every empty class contains an empty class.  */
5002   if (CLASSTYPE_EMPTY_P (t))
5003     CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
5004
5005   /* Set the TYPE_DECL for this type to contain the right
5006      value for DECL_OFFSET, so that we can use it as part
5007      of a COMPONENT_REF for multiple inheritance.  */
5008   layout_decl (TYPE_MAIN_DECL (t), 0);
5009
5010   /* Now fix up any virtual base class types that we left lying
5011      around.  We must get these done before we try to lay out the
5012      virtual function table.  As a side-effect, this will remove the
5013      base subobject fields.  */
5014   layout_virtual_bases (rli, empty_base_offsets);
5015
5016   /* Make sure that empty classes are reflected in RLI at this
5017      point.  */
5018   include_empty_classes(rli);
5019
5020   /* Make sure not to create any structures with zero size.  */
5021   if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
5022     place_field (rli,
5023                  build_decl (FIELD_DECL, NULL_TREE, char_type_node));
5024
5025   /* Let the back end lay out the type.  */
5026   finish_record_layout (rli, /*free_p=*/true);
5027
5028   /* Warn about bases that can't be talked about due to ambiguity.  */
5029   warn_about_ambiguous_bases (t);
5030
5031   /* Now that we're done with layout, give the base fields the real types.  */
5032   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
5033     if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
5034       TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
5035
5036   /* Clean up.  */
5037   splay_tree_delete (empty_base_offsets);
5038
5039   if (CLASSTYPE_EMPTY_P (t)
5040       && tree_int_cst_lt (sizeof_biggest_empty_class,
5041                           TYPE_SIZE_UNIT (t)))
5042     sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
5043 }
5044
5045 /* Determine the "key method" for the class type indicated by TYPE,
5046    and set CLASSTYPE_KEY_METHOD accordingly.  */
5047
5048 void
5049 determine_key_method (tree type)
5050 {
5051   tree method;
5052
5053   if (TYPE_FOR_JAVA (type)
5054       || processing_template_decl
5055       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
5056       || CLASSTYPE_INTERFACE_KNOWN (type))
5057     return;
5058
5059   /* The key method is the first non-pure virtual function that is not
5060      inline at the point of class definition.  On some targets the
5061      key function may not be inline; those targets should not call
5062      this function until the end of the translation unit.  */
5063   for (method = TYPE_METHODS (type); method != NULL_TREE;
5064        method = TREE_CHAIN (method))
5065     if (DECL_VINDEX (method) != NULL_TREE
5066         && ! DECL_DECLARED_INLINE_P (method)
5067         && ! DECL_PURE_VIRTUAL_P (method))
5068       {
5069         CLASSTYPE_KEY_METHOD (type) = method;
5070         break;
5071       }
5072
5073   return;
5074 }
5075
5076 /* Perform processing required when the definition of T (a class type)
5077    is complete.  */
5078
5079 void
5080 finish_struct_1 (tree t)
5081 {
5082   tree x;
5083   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
5084   tree virtuals = NULL_TREE;
5085   int n_fields = 0;
5086
5087   if (COMPLETE_TYPE_P (t))
5088     {
5089       gcc_assert (IS_AGGR_TYPE (t));
5090       error ("redefinition of %q#T", t);
5091       popclass ();
5092       return;
5093     }
5094
5095   /* If this type was previously laid out as a forward reference,
5096      make sure we lay it out again.  */
5097   TYPE_SIZE (t) = NULL_TREE;
5098   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5099
5100   fixup_inline_methods (t);
5101
5102   /* Make assumptions about the class; we'll reset the flags if
5103      necessary.  */
5104   CLASSTYPE_EMPTY_P (t) = 1;
5105   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5106   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5107
5108   /* Do end-of-class semantic processing: checking the validity of the
5109      bases and members and add implicitly generated methods.  */
5110   check_bases_and_members (t);
5111
5112   /* Find the key method.  */
5113   if (TYPE_CONTAINS_VPTR_P (t))
5114     {
5115       /* The Itanium C++ ABI permits the key method to be chosen when
5116          the class is defined -- even though the key method so
5117          selected may later turn out to be an inline function.  On
5118          some systems (such as ARM Symbian OS) the key method cannot
5119          be determined until the end of the translation unit.  On such
5120          systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
5121          will cause the class to be added to KEYED_CLASSES.  Then, in
5122          finish_file we will determine the key method.  */
5123       if (targetm.cxx.key_method_may_be_inline ())
5124         determine_key_method (t);
5125
5126       /* If a polymorphic class has no key method, we may emit the vtable
5127          in every translation unit where the class definition appears.  */
5128       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5129         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5130     }
5131
5132   /* Layout the class itself.  */
5133   layout_class_type (t, &virtuals);
5134   if (CLASSTYPE_AS_BASE (t) != t)
5135     /* We use the base type for trivial assignments, and hence it
5136        needs a mode.  */
5137     compute_record_mode (CLASSTYPE_AS_BASE (t));
5138
5139   virtuals = modify_all_vtables (t, nreverse (virtuals));
5140
5141   /* If necessary, create the primary vtable for this class.  */
5142   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5143     {
5144       /* We must enter these virtuals into the table.  */
5145       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5146         build_primary_vtable (NULL_TREE, t);
5147       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5148         /* Here we know enough to change the type of our virtual
5149            function table, but we will wait until later this function.  */
5150         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5151     }
5152
5153   if (TYPE_CONTAINS_VPTR_P (t))
5154     {
5155       int vindex;
5156       tree fn;
5157
5158       if (BINFO_VTABLE (TYPE_BINFO (t)))
5159         gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
5160       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5161         gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
5162
5163       /* Add entries for virtual functions introduced by this class.  */
5164       BINFO_VIRTUALS (TYPE_BINFO (t))
5165         = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
5166
5167       /* Set DECL_VINDEX for all functions declared in this class.  */
5168       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5169            fn;
5170            fn = TREE_CHAIN (fn),
5171              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5172                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5173         {
5174           tree fndecl = BV_FN (fn);
5175
5176           if (DECL_THUNK_P (fndecl))
5177             /* A thunk. We should never be calling this entry directly
5178                from this vtable -- we'd use the entry for the non
5179                thunk base function.  */
5180             DECL_VINDEX (fndecl) = NULL_TREE;
5181           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5182             DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
5183         }
5184     }
5185
5186   finish_struct_bits (t);
5187
5188   /* Complete the rtl for any static member objects of the type we're
5189      working on.  */
5190   for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5191     if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5192         && TREE_TYPE (x) != error_mark_node
5193         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5194       DECL_MODE (x) = TYPE_MODE (t);
5195
5196   /* Done with FIELDS...now decide whether to sort these for
5197      faster lookups later.
5198
5199      We use a small number because most searches fail (succeeding
5200      ultimately as the search bores through the inheritance
5201      hierarchy), and we want this failure to occur quickly.  */
5202
5203   n_fields = count_fields (TYPE_FIELDS (t));
5204   if (n_fields > 7)
5205     {
5206       struct sorted_fields_type *field_vec = GGC_NEWVAR
5207          (struct sorted_fields_type,
5208           sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
5209       field_vec->len = n_fields;
5210       add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5211       qsort (field_vec->elts, n_fields, sizeof (tree),
5212              field_decl_cmp);
5213       if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5214         retrofit_lang_decl (TYPE_MAIN_DECL (t));
5215       DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5216     }
5217
5218   /* Complain if one of the field types requires lower visibility.  */
5219   constrain_class_visibility (t);
5220
5221   /* Make the rtl for any new vtables we have created, and unmark
5222      the base types we marked.  */
5223   finish_vtbls (t);
5224
5225   /* Build the VTT for T.  */
5226   build_vtt (t);
5227
5228   /* This warning does not make sense for Java classes, since they
5229      cannot have destructors.  */
5230   if (!TYPE_FOR_JAVA (t) && warn_nonvdtor && TYPE_POLYMORPHIC_P (t))
5231     {
5232       tree dtor;
5233
5234       dtor = CLASSTYPE_DESTRUCTORS (t);
5235       if (/* An implicitly declared destructor is always public.  And,
5236              if it were virtual, we would have created it by now.  */
5237           !dtor
5238           || (!DECL_VINDEX (dtor)
5239               && (/* public non-virtual */
5240                   (!TREE_PRIVATE (dtor) && !TREE_PROTECTED (dtor))
5241                    || (/* non-public non-virtual with friends */
5242                        (TREE_PRIVATE (dtor) || TREE_PROTECTED (dtor))
5243                         && (CLASSTYPE_FRIEND_CLASSES (t)
5244                         || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))))))
5245         warning (OPT_Wnon_virtual_dtor,
5246                  "%q#T has virtual functions and accessible"
5247                  " non-virtual destructor", t);
5248     }
5249
5250   complete_vars (t);
5251
5252   if (warn_overloaded_virtual)
5253     warn_hidden (t);
5254
5255   /* Class layout, assignment of virtual table slots, etc., is now
5256      complete.  Give the back end a chance to tweak the visibility of
5257      the class or perform any other required target modifications.  */
5258   targetm.cxx.adjust_class_at_definition (t);
5259
5260   maybe_suppress_debug_info (t);
5261
5262   dump_class_hierarchy (t);
5263
5264   /* Finish debugging output for this type.  */
5265   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5266 }
5267
5268 /* When T was built up, the member declarations were added in reverse
5269    order.  Rearrange them to declaration order.  */
5270
5271 void
5272 unreverse_member_declarations (tree t)
5273 {
5274   tree next;
5275   tree prev;
5276   tree x;
5277
5278   /* The following lists are all in reverse order.  Put them in
5279      declaration order now.  */
5280   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5281   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5282
5283   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5284      reverse order, so we can't just use nreverse.  */
5285   prev = NULL_TREE;
5286   for (x = TYPE_FIELDS (t);
5287        x && TREE_CODE (x) != TYPE_DECL;
5288        x = next)
5289     {
5290       next = TREE_CHAIN (x);
5291       TREE_CHAIN (x) = prev;
5292       prev = x;
5293     }
5294   if (prev)
5295     {
5296       TREE_CHAIN (TYPE_FIELDS (t)) = x;
5297       if (prev)
5298         TYPE_FIELDS (t) = prev;
5299     }
5300 }
5301
5302 tree
5303 finish_struct (tree t, tree attributes)
5304 {
5305   location_t saved_loc = input_location;
5306
5307   /* Now that we've got all the field declarations, reverse everything
5308      as necessary.  */
5309   unreverse_member_declarations (t);
5310
5311   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5312
5313   /* Nadger the current location so that diagnostics point to the start of
5314      the struct, not the end.  */
5315   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5316
5317   if (processing_template_decl)
5318     {
5319       tree x;
5320
5321       finish_struct_methods (t);
5322       TYPE_SIZE (t) = bitsize_zero_node;
5323       TYPE_SIZE_UNIT (t) = size_zero_node;
5324
5325       /* We need to emit an error message if this type was used as a parameter
5326          and it is an abstract type, even if it is a template. We construct
5327          a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5328          account and we call complete_vars with this type, which will check
5329          the PARM_DECLS. Note that while the type is being defined,
5330          CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5331          (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it.  */
5332       CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5333       for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
5334         if (DECL_PURE_VIRTUAL_P (x))
5335           VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
5336       complete_vars (t);
5337     }
5338   else
5339     finish_struct_1 (t);
5340
5341   input_location = saved_loc;
5342
5343   TYPE_BEING_DEFINED (t) = 0;
5344
5345   if (current_class_type)
5346     popclass ();
5347   else
5348     error ("trying to finish struct, but kicked out due to previous parse errors");
5349
5350   if (processing_template_decl && at_function_scope_p ())
5351     add_stmt (build_min (TAG_DEFN, t));
5352
5353   return t;
5354 }
5355 \f
5356 /* Return the dynamic type of INSTANCE, if known.
5357    Used to determine whether the virtual function table is needed
5358    or not.
5359
5360    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5361    of our knowledge of its type.  *NONNULL should be initialized
5362    before this function is called.  */
5363
5364 static tree
5365 fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
5366 {
5367 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
5368
5369   switch (TREE_CODE (instance))
5370     {
5371     case INDIRECT_REF:
5372       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5373         return NULL_TREE;
5374       else
5375         return RECUR (TREE_OPERAND (instance, 0));
5376
5377     case CALL_EXPR:
5378       /* This is a call to a constructor, hence it's never zero.  */
5379       if (TREE_HAS_CONSTRUCTOR (instance))
5380         {
5381           if (nonnull)
5382             *nonnull = 1;
5383           return TREE_TYPE (instance);
5384         }
5385       return NULL_TREE;
5386
5387     case SAVE_EXPR:
5388       /* This is a call to a constructor, hence it's never zero.  */
5389       if (TREE_HAS_CONSTRUCTOR (instance))
5390         {
5391           if (nonnull)
5392             *nonnull = 1;
5393           return TREE_TYPE (instance);
5394         }
5395       return RECUR (TREE_OPERAND (instance, 0));
5396
5397     case POINTER_PLUS_EXPR:
5398     case PLUS_EXPR:
5399     case MINUS_EXPR:
5400       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5401         return RECUR (TREE_OPERAND (instance, 0));
5402       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5403         /* Propagate nonnull.  */
5404         return RECUR (TREE_OPERAND (instance, 0));
5405
5406       return NULL_TREE;
5407
5408     case NOP_EXPR:
5409     case CONVERT_EXPR:
5410       return RECUR (TREE_OPERAND (instance, 0));
5411
5412     case ADDR_EXPR:
5413       instance = TREE_OPERAND (instance, 0);
5414       if (nonnull)
5415         {
5416           /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5417              with a real object -- given &p->f, p can still be null.  */
5418           tree t = get_base_address (instance);
5419           /* ??? Probably should check DECL_WEAK here.  */
5420           if (t && DECL_P (t))
5421             *nonnull = 1;
5422         }
5423       return RECUR (instance);
5424
5425     case COMPONENT_REF:
5426       /* If this component is really a base class reference, then the field
5427          itself isn't definitive.  */
5428       if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5429         return RECUR (TREE_OPERAND (instance, 0));
5430       return RECUR (TREE_OPERAND (instance, 1));
5431
5432     case VAR_DECL:
5433     case FIELD_DECL:
5434       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5435           && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
5436         {
5437           if (nonnull)
5438             *nonnull = 1;
5439           return TREE_TYPE (TREE_TYPE (instance));
5440         }
5441       /* fall through...  */
5442     case TARGET_EXPR:
5443     case PARM_DECL:
5444     case RESULT_DECL:
5445       if (IS_AGGR_TYPE (TREE_TYPE (instance)))
5446         {
5447           if (nonnull)
5448             *nonnull = 1;
5449           return TREE_TYPE (instance);
5450         }
5451       else if (instance == current_class_ptr)
5452         {
5453           if (nonnull)
5454             *nonnull = 1;
5455
5456           /* if we're in a ctor or dtor, we know our type.  */
5457           if (DECL_LANG_SPECIFIC (current_function_decl)
5458               && (DECL_CONSTRUCTOR_P (current_function_decl)
5459                   || DECL_DESTRUCTOR_P (current_function_decl)))
5460             {
5461               if (cdtorp)
5462                 *cdtorp = 1;
5463               return TREE_TYPE (TREE_TYPE (instance));
5464             }
5465         }
5466       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5467         {
5468           /* We only need one hash table because it is always left empty.  */
5469           static htab_t ht;
5470           if (!ht)
5471             ht = htab_create (37,
5472                               htab_hash_pointer,
5473                               htab_eq_pointer,
5474                               /*htab_del=*/NULL);
5475
5476           /* Reference variables should be references to objects.  */
5477           if (nonnull)
5478             *nonnull = 1;
5479
5480           /* Enter the INSTANCE in a table to prevent recursion; a
5481              variable's initializer may refer to the variable
5482              itself.  */
5483           if (TREE_CODE (instance) == VAR_DECL
5484               && DECL_INITIAL (instance)
5485               && !htab_find (ht, instance))
5486             {
5487               tree type;
5488               void **slot;
5489
5490               slot = htab_find_slot (ht, instance, INSERT);
5491               *slot = instance;
5492               type = RECUR (DECL_INITIAL (instance));
5493               htab_remove_elt (ht, instance);
5494
5495               return type;
5496             }
5497         }
5498       return NULL_TREE;
5499
5500     default:
5501       return NULL_TREE;
5502     }
5503 #undef RECUR
5504 }
5505
5506 /* Return nonzero if the dynamic type of INSTANCE is known, and
5507    equivalent to the static type.  We also handle the case where
5508    INSTANCE is really a pointer. Return negative if this is a
5509    ctor/dtor. There the dynamic type is known, but this might not be
5510    the most derived base of the original object, and hence virtual
5511    bases may not be layed out according to this type.
5512
5513    Used to determine whether the virtual function table is needed
5514    or not.
5515
5516    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5517    of our knowledge of its type.  *NONNULL should be initialized
5518    before this function is called.  */
5519
5520 int
5521 resolves_to_fixed_type_p (tree instance, int* nonnull)
5522 {
5523   tree t = TREE_TYPE (instance);
5524   int cdtorp = 0;
5525   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5526   if (fixed == NULL_TREE)
5527     return 0;
5528   if (POINTER_TYPE_P (t))
5529     t = TREE_TYPE (t);
5530   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5531     return 0;
5532   return cdtorp ? -1 : 1;
5533 }
5534
5535 \f
5536 void
5537 init_class_processing (void)
5538 {
5539   current_class_depth = 0;
5540   current_class_stack_size = 10;
5541   current_class_stack
5542     = XNEWVEC (struct class_stack_node, current_class_stack_size);
5543   local_classes = VEC_alloc (tree, gc, 8);
5544   sizeof_biggest_empty_class = size_zero_node;
5545
5546   ridpointers[(int) RID_PUBLIC] = access_public_node;
5547   ridpointers[(int) RID_PRIVATE] = access_private_node;
5548   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5549 }
5550
5551 /* Restore the cached PREVIOUS_CLASS_LEVEL.  */
5552
5553 static void
5554 restore_class_cache (void)
5555 {
5556   tree type;
5557
5558   /* We are re-entering the same class we just left, so we don't
5559      have to search the whole inheritance matrix to find all the
5560      decls to bind again.  Instead, we install the cached
5561      class_shadowed list and walk through it binding names.  */
5562   push_binding_level (previous_class_level);
5563   class_binding_level = previous_class_level;
5564   /* Restore IDENTIFIER_TYPE_VALUE.  */
5565   for (type = class_binding_level->type_shadowed;
5566        type;
5567        type = TREE_CHAIN (type))
5568     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5569 }
5570
5571 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5572    appropriate for TYPE.
5573
5574    So that we may avoid calls to lookup_name, we cache the _TYPE
5575    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5576
5577    For multiple inheritance, we perform a two-pass depth-first search
5578    of the type lattice.  */
5579
5580 void
5581 pushclass (tree type)
5582 {
5583   class_stack_node_t csn;
5584
5585   type = TYPE_MAIN_VARIANT (type);
5586
5587   /* Make sure there is enough room for the new entry on the stack.  */
5588   if (current_class_depth + 1 >= current_class_stack_size)
5589     {
5590       current_class_stack_size *= 2;
5591       current_class_stack
5592         = XRESIZEVEC (struct class_stack_node, current_class_stack,
5593                       current_class_stack_size);
5594     }
5595
5596   /* Insert a new entry on the class stack.  */
5597   csn = current_class_stack + current_class_depth;
5598   csn->name = current_class_name;
5599   csn->type = current_class_type;
5600   csn->access = current_access_specifier;
5601   csn->names_used = 0;
5602   csn->hidden = 0;
5603   current_class_depth++;
5604
5605   /* Now set up the new type.  */
5606   current_class_name = TYPE_NAME (type);
5607   if (TREE_CODE (current_class_name) == TYPE_DECL)
5608     current_class_name = DECL_NAME (current_class_name);
5609   current_class_type = type;
5610
5611   /* By default, things in classes are private, while things in
5612      structures or unions are public.  */
5613   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5614                               ? access_private_node
5615                               : access_public_node);
5616
5617   if (previous_class_level
5618       && type != previous_class_level->this_entity
5619       && current_class_depth == 1)
5620     {
5621       /* Forcibly remove any old class remnants.  */
5622       invalidate_class_lookup_cache ();
5623     }
5624
5625   if (!previous_class_level
5626       || type != previous_class_level->this_entity
5627       || current_class_depth > 1)
5628     pushlevel_class ();
5629   else
5630     restore_class_cache ();
5631 }
5632
5633 /* When we exit a toplevel class scope, we save its binding level so
5634    that we can restore it quickly.  Here, we've entered some other
5635    class, so we must invalidate our cache.  */
5636
5637 void
5638 invalidate_class_lookup_cache (void)
5639 {
5640   previous_class_level = NULL;
5641 }
5642
5643 /* Get out of the current class scope. If we were in a class scope
5644    previously, that is the one popped to.  */
5645
5646 void
5647 popclass (void)
5648 {
5649   poplevel_class ();
5650
5651   current_class_depth--;
5652   current_class_name = current_class_stack[current_class_depth].name;
5653   current_class_type = current_class_stack[current_class_depth].type;
5654   current_access_specifier = current_class_stack[current_class_depth].access;
5655   if (current_class_stack[current_class_depth].names_used)
5656     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5657 }
5658
5659 /* Mark the top of the class stack as hidden.  */
5660
5661 void
5662 push_class_stack (void)
5663 {
5664   if (current_class_depth)
5665     ++current_class_stack[current_class_depth - 1].hidden;
5666 }
5667
5668 /* Mark the top of the class stack as un-hidden.  */
5669
5670 void
5671 pop_class_stack (void)
5672 {
5673   if (current_class_depth)
5674     --current_class_stack[current_class_depth - 1].hidden;
5675 }
5676
5677 /* Returns 1 if the class type currently being defined is either T or
5678    a nested type of T.  */
5679
5680 bool
5681 currently_open_class (tree t)
5682 {
5683   int i;
5684
5685   /* We start looking from 1 because entry 0 is from global scope,
5686      and has no type.  */
5687   for (i = current_class_depth; i > 0; --i)
5688     {
5689       tree c;
5690       if (i == current_class_depth)
5691         c = current_class_type;
5692       else
5693         {
5694           if (current_class_stack[i].hidden)
5695             break;
5696           c = current_class_stack[i].type;
5697         }
5698       if (!c)
5699         continue;
5700       if (same_type_p (c, t))
5701         return true;
5702     }
5703   return false;
5704 }
5705
5706 /* If either current_class_type or one of its enclosing classes are derived
5707    from T, return the appropriate type.  Used to determine how we found
5708    something via unqualified lookup.  */
5709
5710 tree
5711 currently_open_derived_class (tree t)
5712 {
5713   int i;
5714
5715   /* The bases of a dependent type are unknown.  */
5716   if (dependent_type_p (t))
5717     return NULL_TREE;
5718
5719   if (!current_class_type)
5720     return NULL_TREE;
5721
5722   if (DERIVED_FROM_P (t, current_class_type))
5723     return current_class_type;
5724
5725   for (i = current_class_depth - 1; i > 0; --i)
5726     {
5727       if (current_class_stack[i].hidden)
5728         break;
5729       if (DERIVED_FROM_P (t, current_class_stack[i].type))
5730         return current_class_stack[i].type;
5731     }
5732
5733   return NULL_TREE;
5734 }
5735
5736 /* When entering a class scope, all enclosing class scopes' names with
5737    static meaning (static variables, static functions, types and
5738    enumerators) have to be visible.  This recursive function calls
5739    pushclass for all enclosing class contexts until global or a local
5740    scope is reached.  TYPE is the enclosed class.  */
5741
5742 void
5743 push_nested_class (tree type)
5744 {
5745   /* A namespace might be passed in error cases, like A::B:C.  */
5746   if (type == NULL_TREE
5747       || !CLASS_TYPE_P (type))
5748     return;
5749
5750   push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type)));
5751
5752   pushclass (type);
5753 }
5754
5755 /* Undoes a push_nested_class call.  */
5756
5757 void
5758 pop_nested_class (void)
5759 {
5760   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5761
5762   popclass ();
5763   if (context && CLASS_TYPE_P (context))
5764     pop_nested_class ();
5765 }
5766
5767 /* Returns the number of extern "LANG" blocks we are nested within.  */
5768
5769 int
5770 current_lang_depth (void)
5771 {
5772   return VEC_length (tree, current_lang_base);
5773 }
5774
5775 /* Set global variables CURRENT_LANG_NAME to appropriate value
5776    so that behavior of name-mangling machinery is correct.  */
5777
5778 void
5779 push_lang_context (tree name)
5780 {
5781   VEC_safe_push (tree, gc, current_lang_base, current_lang_name);
5782
5783   if (name == lang_name_cplusplus)
5784     {
5785       current_lang_name = name;
5786     }
5787   else if (name == lang_name_java)
5788     {
5789       current_lang_name = name;
5790       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5791          (See record_builtin_java_type in decl.c.)  However, that causes
5792          incorrect debug entries if these types are actually used.
5793          So we re-enable debug output after extern "Java".  */
5794       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5795       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5796       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5797       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5798       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5799       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5800       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5801       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5802     }
5803   else if (name == lang_name_c)
5804     {
5805       current_lang_name = name;
5806     }
5807   else
5808     error ("language string %<\"%E\"%> not recognized", name);
5809 }
5810
5811 /* Get out of the current language scope.  */
5812
5813 void
5814 pop_lang_context (void)
5815 {
5816   current_lang_name = VEC_pop (tree, current_lang_base);
5817 }
5818 \f
5819 /* Type instantiation routines.  */
5820
5821 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5822    matches the TARGET_TYPE.  If there is no satisfactory match, return
5823    error_mark_node, and issue an error & warning messages under
5824    control of FLAGS.  Permit pointers to member function if FLAGS
5825    permits.  If TEMPLATE_ONLY, the name of the overloaded function was
5826    a template-id, and EXPLICIT_TARGS are the explicitly provided
5827    template arguments.  If OVERLOAD is for one or more member
5828    functions, then ACCESS_PATH is the base path used to reference
5829    those member functions.  */
5830
5831 static tree
5832 resolve_address_of_overloaded_function (tree target_type,
5833                                         tree overload,
5834                                         tsubst_flags_t flags,
5835                                         bool template_only,
5836                                         tree explicit_targs,
5837                                         tree access_path)
5838 {
5839   /* Here's what the standard says:
5840
5841        [over.over]
5842
5843        If the name is a function template, template argument deduction
5844        is done, and if the argument deduction succeeds, the deduced
5845        arguments are used to generate a single template function, which
5846        is added to the set of overloaded functions considered.
5847
5848        Non-member functions and static member functions match targets of
5849        type "pointer-to-function" or "reference-to-function."  Nonstatic
5850        member functions match targets of type "pointer-to-member
5851        function;" the function type of the pointer to member is used to
5852        select the member function from the set of overloaded member
5853        functions.  If a nonstatic member function is selected, the
5854        reference to the overloaded function name is required to have the
5855        form of a pointer to member as described in 5.3.1.
5856
5857        If more than one function is selected, any template functions in
5858        the set are eliminated if the set also contains a non-template
5859        function, and any given template function is eliminated if the
5860        set contains a second template function that is more specialized
5861        than the first according to the partial ordering rules 14.5.5.2.
5862        After such eliminations, if any, there shall remain exactly one
5863        selected function.  */
5864
5865   int is_ptrmem = 0;
5866   int is_reference = 0;
5867   /* We store the matches in a TREE_LIST rooted here.  The functions
5868      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5869      interoperability with most_specialized_instantiation.  */
5870   tree matches = NULL_TREE;
5871   tree fn;
5872
5873   /* By the time we get here, we should be seeing only real
5874      pointer-to-member types, not the internal POINTER_TYPE to
5875      METHOD_TYPE representation.  */
5876   gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
5877               || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
5878
5879   gcc_assert (is_overloaded_fn (overload));
5880
5881   /* Check that the TARGET_TYPE is reasonable.  */
5882   if (TYPE_PTRFN_P (target_type))
5883     /* This is OK.  */;
5884   else if (TYPE_PTRMEMFUNC_P (target_type))
5885     /* This is OK, too.  */
5886     is_ptrmem = 1;
5887   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5888     {
5889       /* This is OK, too.  This comes from a conversion to reference
5890          type.  */
5891       target_type = build_reference_type (target_type);
5892       is_reference = 1;
5893     }
5894   else
5895     {
5896       if (flags & tf_error)
5897         error ("cannot resolve overloaded function %qD based on"
5898                " conversion to type %qT",
5899                DECL_NAME (OVL_FUNCTION (overload)), target_type);
5900       return error_mark_node;
5901     }
5902
5903   /* If we can find a non-template function that matches, we can just
5904      use it.  There's no point in generating template instantiations
5905      if we're just going to throw them out anyhow.  But, of course, we
5906      can only do this when we don't *need* a template function.  */
5907   if (!template_only)
5908     {
5909       tree fns;
5910
5911       for (fns = overload; fns; fns = OVL_NEXT (fns))
5912         {
5913           tree fn = OVL_CURRENT (fns);
5914           tree fntype;
5915
5916           if (TREE_CODE (fn) == TEMPLATE_DECL)
5917             /* We're not looking for templates just yet.  */
5918             continue;
5919
5920           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5921               != is_ptrmem)
5922             /* We're looking for a non-static member, and this isn't
5923                one, or vice versa.  */
5924             continue;
5925
5926           /* Ignore functions which haven't been explicitly
5927              declared.  */
5928           if (DECL_ANTICIPATED (fn))
5929             continue;
5930
5931           /* See if there's a match.  */
5932           fntype = TREE_TYPE (fn);
5933           if (is_ptrmem)
5934             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5935           else if (!is_reference)
5936             fntype = build_pointer_type (fntype);
5937
5938           if (can_convert_arg (target_type, fntype, fn, LOOKUP_NORMAL))
5939             matches = tree_cons (fn, NULL_TREE, matches);
5940         }
5941     }
5942
5943   /* Now, if we've already got a match (or matches), there's no need
5944      to proceed to the template functions.  But, if we don't have a
5945      match we need to look at them, too.  */
5946   if (!matches)
5947     {
5948       tree target_fn_type;
5949       tree target_arg_types;
5950       tree target_ret_type;
5951       tree fns;
5952
5953       if (is_ptrmem)
5954         target_fn_type
5955           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5956       else
5957         target_fn_type = TREE_TYPE (target_type);
5958       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5959       target_ret_type = TREE_TYPE (target_fn_type);
5960
5961       /* Never do unification on the 'this' parameter.  */
5962       if (TREE_CODE (target_fn_type) == METHOD_TYPE)
5963         target_arg_types = TREE_CHAIN (target_arg_types);
5964
5965       for (fns = overload; fns; fns = OVL_NEXT (fns))
5966         {
5967           tree fn = OVL_CURRENT (fns);
5968           tree instantiation;
5969           tree instantiation_type;
5970           tree targs;
5971
5972           if (TREE_CODE (fn) != TEMPLATE_DECL)
5973             /* We're only looking for templates.  */
5974             continue;
5975
5976           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5977               != is_ptrmem)
5978             /* We're not looking for a non-static member, and this is
5979                one, or vice versa.  */
5980             continue;
5981
5982           /* Try to do argument deduction.  */
5983           targs = make_tree_vec (DECL_NTPARMS (fn));
5984           if (fn_type_unification (fn, explicit_targs, targs,
5985                                    target_arg_types, target_ret_type,
5986                                    DEDUCE_EXACT, LOOKUP_NORMAL))
5987             /* Argument deduction failed.  */
5988             continue;
5989
5990           /* Instantiate the template.  */
5991           instantiation = instantiate_template (fn, targs, flags);
5992           if (instantiation == error_mark_node)
5993             /* Instantiation failed.  */
5994             continue;
5995
5996           /* See if there's a match.  */
5997           instantiation_type = TREE_TYPE (instantiation);
5998           if (is_ptrmem)
5999             instantiation_type =
6000               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
6001           else if (!is_reference)
6002             instantiation_type = build_pointer_type (instantiation_type);
6003           if (can_convert_arg (target_type, instantiation_type, instantiation,
6004                                LOOKUP_NORMAL))
6005             matches = tree_cons (instantiation, fn, matches);
6006         }
6007
6008       /* Now, remove all but the most specialized of the matches.  */
6009       if (matches)
6010         {
6011           tree match = most_specialized_instantiation (matches);
6012
6013           if (match != error_mark_node)
6014             matches = tree_cons (TREE_PURPOSE (match),
6015                                  NULL_TREE,
6016                                  NULL_TREE);
6017         }
6018     }
6019
6020   /* Now we should have exactly one function in MATCHES.  */
6021   if (matches == NULL_TREE)
6022     {
6023       /* There were *no* matches.  */
6024       if (flags & tf_error)
6025         {
6026           error ("no matches converting function %qD to type %q#T",
6027                  DECL_NAME (OVL_FUNCTION (overload)),
6028                  target_type);
6029
6030           /* print_candidates expects a chain with the functions in
6031              TREE_VALUE slots, so we cons one up here (we're losing anyway,
6032              so why be clever?).  */
6033           for (; overload; overload = OVL_NEXT (overload))
6034             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
6035                                  matches);
6036
6037           print_candidates (matches);
6038         }
6039       return error_mark_node;
6040     }
6041   else if (TREE_CHAIN (matches))
6042     {
6043       /* There were too many matches.  */
6044
6045       if (flags & tf_error)
6046         {
6047           tree match;
6048
6049           error ("converting overloaded function %qD to type %q#T is ambiguous",
6050                     DECL_NAME (OVL_FUNCTION (overload)),
6051                     target_type);
6052
6053           /* Since print_candidates expects the functions in the
6054              TREE_VALUE slot, we flip them here.  */
6055           for (match = matches; match; match = TREE_CHAIN (match))
6056             TREE_VALUE (match) = TREE_PURPOSE (match);
6057
6058           print_candidates (matches);
6059         }
6060
6061       return error_mark_node;
6062     }
6063
6064   /* Good, exactly one match.  Now, convert it to the correct type.  */
6065   fn = TREE_PURPOSE (matches);
6066
6067   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
6068       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
6069     {
6070       static int explained;
6071
6072       if (!(flags & tf_error))
6073         return error_mark_node;
6074
6075       pedwarn ("assuming pointer to member %qD", fn);
6076       if (!explained)
6077         {
6078           pedwarn ("(a pointer to member can only be formed with %<&%E%>)", fn);
6079           explained = 1;
6080         }
6081     }
6082
6083   /* If we're doing overload resolution purely for the purpose of
6084      determining conversion sequences, we should not consider the
6085      function used.  If this conversion sequence is selected, the
6086      function will be marked as used at this point.  */
6087   if (!(flags & tf_conv))
6088     {
6089       mark_used (fn);
6090       /* We could not check access when this expression was originally
6091          created since we did not know at that time to which function
6092          the expression referred.  */
6093       if (DECL_FUNCTION_MEMBER_P (fn))
6094         {
6095           gcc_assert (access_path);
6096           perform_or_defer_access_check (access_path, fn, fn);
6097         }
6098     }
6099
6100   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
6101     return build_unary_op (ADDR_EXPR, fn, 0);
6102   else
6103     {
6104       /* The target must be a REFERENCE_TYPE.  Above, build_unary_op
6105          will mark the function as addressed, but here we must do it
6106          explicitly.  */
6107       cxx_mark_addressable (fn);
6108
6109       return fn;
6110     }
6111 }
6112
6113 /* This function will instantiate the type of the expression given in
6114    RHS to match the type of LHSTYPE.  If errors exist, then return
6115    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
6116    we complain on errors.  If we are not complaining, never modify rhs,
6117    as overload resolution wants to try many possible instantiations, in
6118    the hope that at least one will work.
6119
6120    For non-recursive calls, LHSTYPE should be a function, pointer to
6121    function, or a pointer to member function.  */
6122
6123 tree
6124 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6125 {
6126   tsubst_flags_t flags_in = flags;
6127   tree access_path = NULL_TREE;
6128
6129   flags &= ~tf_ptrmem_ok;
6130
6131   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
6132     {
6133       if (flags & tf_error)
6134         error ("not enough type information");
6135       return error_mark_node;
6136     }
6137
6138   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6139     {
6140       if (same_type_p (lhstype, TREE_TYPE (rhs)))
6141         return rhs;
6142       if (flag_ms_extensions
6143           && TYPE_PTRMEMFUNC_P (lhstype)
6144           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6145         /* Microsoft allows `A::f' to be resolved to a
6146            pointer-to-member.  */
6147         ;
6148       else
6149         {
6150           if (flags & tf_error)
6151             error ("argument of type %qT does not match %qT",
6152                    TREE_TYPE (rhs), lhstype);
6153           return error_mark_node;
6154         }
6155     }
6156
6157   if (TREE_CODE (rhs) == BASELINK)
6158     {
6159       access_path = BASELINK_ACCESS_BINFO (rhs);
6160       rhs = BASELINK_FUNCTIONS (rhs);
6161     }
6162
6163   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6164      deduce any type information.  */
6165   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6166     {
6167       if (flags & tf_error)
6168         error ("not enough type information");
6169       return error_mark_node;
6170     }
6171
6172   /* There only a few kinds of expressions that may have a type
6173      dependent on overload resolution.  */
6174   gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6175               || TREE_CODE (rhs) == COMPONENT_REF
6176               || TREE_CODE (rhs) == COMPOUND_EXPR
6177               || really_overloaded_fn (rhs));
6178
6179   /* We don't overwrite rhs if it is an overloaded function.
6180      Copying it would destroy the tree link.  */
6181   if (TREE_CODE (rhs) != OVERLOAD)
6182     rhs = copy_node (rhs);
6183
6184   /* This should really only be used when attempting to distinguish
6185      what sort of a pointer to function we have.  For now, any
6186      arithmetic operation which is not supported on pointers
6187      is rejected as an error.  */
6188
6189   switch (TREE_CODE (rhs))
6190     {
6191     case COMPONENT_REF:
6192       {
6193         tree member = TREE_OPERAND (rhs, 1);
6194
6195         member = instantiate_type (lhstype, member, flags);
6196         if (member != error_mark_node
6197             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6198           /* Do not lose object's side effects.  */
6199           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6200                          TREE_OPERAND (rhs, 0), member);
6201         return member;
6202       }
6203
6204     case OFFSET_REF:
6205       rhs = TREE_OPERAND (rhs, 1);
6206       if (BASELINK_P (rhs))
6207         return instantiate_type (lhstype, rhs, flags_in);
6208
6209       /* This can happen if we are forming a pointer-to-member for a
6210          member template.  */
6211       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6212
6213       /* Fall through.  */
6214
6215     case TEMPLATE_ID_EXPR:
6216       {
6217         tree fns = TREE_OPERAND (rhs, 0);
6218         tree args = TREE_OPERAND (rhs, 1);
6219
6220         return
6221           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6222                                                   /*template_only=*/true,
6223                                                   args, access_path);
6224       }
6225
6226     case OVERLOAD:
6227     case FUNCTION_DECL:
6228       return
6229         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6230                                                 /*template_only=*/false,
6231                                                 /*explicit_targs=*/NULL_TREE,
6232                                                 access_path);
6233
6234     case COMPOUND_EXPR:
6235       TREE_OPERAND (rhs, 0)
6236         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6237       if (TREE_OPERAND (rhs, 0) == error_mark_node)
6238         return error_mark_node;
6239       TREE_OPERAND (rhs, 1)
6240         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6241       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6242         return error_mark_node;
6243
6244       TREE_TYPE (rhs) = lhstype;
6245       return rhs;
6246
6247     case ADDR_EXPR:
6248     {
6249       if (PTRMEM_OK_P (rhs))
6250         flags |= tf_ptrmem_ok;
6251
6252       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6253     }
6254
6255     case ERROR_MARK:
6256       return error_mark_node;
6257
6258     default:
6259       gcc_unreachable ();
6260     }
6261   return error_mark_node;
6262 }
6263 \f
6264 /* Return the name of the virtual function pointer field
6265    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6266    this may have to look back through base types to find the
6267    ultimate field name.  (For single inheritance, these could
6268    all be the same name.  Who knows for multiple inheritance).  */
6269
6270 static tree
6271 get_vfield_name (tree type)
6272 {
6273   tree binfo, base_binfo;
6274   char *buf;
6275
6276   for (binfo = TYPE_BINFO (type);
6277        BINFO_N_BASE_BINFOS (binfo);
6278        binfo = base_binfo)
6279     {
6280       base_binfo = BINFO_BASE_BINFO (binfo, 0);
6281
6282       if (BINFO_VIRTUAL_P (base_binfo)
6283           || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6284         break;
6285     }
6286
6287   type = BINFO_TYPE (binfo);
6288   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6289                          + TYPE_NAME_LENGTH (type) + 2);
6290   sprintf (buf, VFIELD_NAME_FORMAT,
6291            IDENTIFIER_POINTER (constructor_name (type)));
6292   return get_identifier (buf);
6293 }
6294
6295 void
6296 print_class_statistics (void)
6297 {
6298 #ifdef GATHER_STATISTICS
6299   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6300   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6301   if (n_vtables)
6302     {
6303       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6304                n_vtables, n_vtable_searches);
6305       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6306                n_vtable_entries, n_vtable_elems);
6307     }
6308 #endif
6309 }
6310
6311 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6312    according to [class]:
6313                                           The class-name is also inserted
6314    into  the scope of the class itself.  For purposes of access checking,
6315    the inserted class name is treated as if it were a public member name.  */
6316
6317 void
6318 build_self_reference (void)
6319 {
6320   tree name = constructor_name (current_class_type);
6321   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6322   tree saved_cas;
6323
6324   DECL_NONLOCAL (value) = 1;
6325   DECL_CONTEXT (value) = current_class_type;
6326   DECL_ARTIFICIAL (value) = 1;
6327   SET_DECL_SELF_REFERENCE_P (value);
6328
6329   if (processing_template_decl)
6330     value = push_template_decl (value);
6331
6332   saved_cas = current_access_specifier;
6333   current_access_specifier = access_public_node;
6334   finish_member_declaration (value);
6335   current_access_specifier = saved_cas;
6336 }
6337
6338 /* Returns 1 if TYPE contains only padding bytes.  */
6339
6340 int
6341 is_empty_class (tree type)
6342 {
6343   if (type == error_mark_node)
6344     return 0;
6345
6346   if (! IS_AGGR_TYPE (type))
6347     return 0;
6348
6349   /* In G++ 3.2, whether or not a class was empty was determined by
6350      looking at its size.  */
6351   if (abi_version_at_least (2))
6352     return CLASSTYPE_EMPTY_P (type);
6353   else
6354     return integer_zerop (CLASSTYPE_SIZE (type));
6355 }
6356
6357 /* Returns true if TYPE contains an empty class.  */
6358
6359 static bool
6360 contains_empty_class_p (tree type)
6361 {
6362   if (is_empty_class (type))
6363     return true;
6364   if (CLASS_TYPE_P (type))
6365     {
6366       tree field;
6367       tree binfo;
6368       tree base_binfo;
6369       int i;
6370
6371       for (binfo = TYPE_BINFO (type), i = 0;
6372            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6373         if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6374           return true;
6375       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6376         if (TREE_CODE (field) == FIELD_DECL
6377             && !DECL_ARTIFICIAL (field)
6378             && is_empty_class (TREE_TYPE (field)))
6379           return true;
6380     }
6381   else if (TREE_CODE (type) == ARRAY_TYPE)
6382     return contains_empty_class_p (TREE_TYPE (type));
6383   return false;
6384 }
6385
6386 /* Note that NAME was looked up while the current class was being
6387    defined and that the result of that lookup was DECL.  */
6388
6389 void
6390 maybe_note_name_used_in_class (tree name, tree decl)
6391 {
6392   splay_tree names_used;
6393
6394   /* If we're not defining a class, there's nothing to do.  */
6395   if (!(innermost_scope_kind() == sk_class
6396         && TYPE_BEING_DEFINED (current_class_type)))
6397     return;
6398
6399   /* If there's already a binding for this NAME, then we don't have
6400      anything to worry about.  */
6401   if (lookup_member (current_class_type, name,
6402                      /*protect=*/0, /*want_type=*/false))
6403     return;
6404
6405   if (!current_class_stack[current_class_depth - 1].names_used)
6406     current_class_stack[current_class_depth - 1].names_used
6407       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6408   names_used = current_class_stack[current_class_depth - 1].names_used;
6409
6410   splay_tree_insert (names_used,
6411                      (splay_tree_key) name,
6412                      (splay_tree_value) decl);
6413 }
6414
6415 /* Note that NAME was declared (as DECL) in the current class.  Check
6416    to see that the declaration is valid.  */
6417
6418 void
6419 note_name_declared_in_class (tree name, tree decl)
6420 {
6421   splay_tree names_used;
6422   splay_tree_node n;
6423
6424   /* Look to see if we ever used this name.  */
6425   names_used
6426     = current_class_stack[current_class_depth - 1].names_used;
6427   if (!names_used)
6428     return;
6429
6430   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6431   if (n)
6432     {
6433       /* [basic.scope.class]
6434
6435          A name N used in a class S shall refer to the same declaration
6436          in its context and when re-evaluated in the completed scope of
6437          S.  */
6438       pedwarn ("declaration of %q#D", decl);
6439       pedwarn ("changes meaning of %qD from %q+#D",
6440                DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
6441     }
6442 }
6443
6444 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6445    Secondary vtables are merged with primary vtables; this function
6446    will return the VAR_DECL for the primary vtable.  */
6447
6448 tree
6449 get_vtbl_decl_for_binfo (tree binfo)
6450 {
6451   tree decl;
6452
6453   decl = BINFO_VTABLE (binfo);
6454   if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR)
6455     {
6456       gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6457       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6458     }
6459   if (decl)
6460     gcc_assert (TREE_CODE (decl) == VAR_DECL);
6461   return decl;
6462 }
6463
6464
6465 /* Returns the binfo for the primary base of BINFO.  If the resulting
6466    BINFO is a virtual base, and it is inherited elsewhere in the
6467    hierarchy, then the returned binfo might not be the primary base of
6468    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6469    BINFO_LOST_PRIMARY_P to be sure.  */
6470
6471 static tree
6472 get_primary_binfo (tree binfo)
6473 {
6474   tree primary_base;
6475
6476   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6477   if (!primary_base)
6478     return NULL_TREE;
6479
6480   return copied_binfo (primary_base, binfo);
6481 }
6482
6483 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6484
6485 static int
6486 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6487 {
6488   if (!indented_p)
6489     fprintf (stream, "%*s", indent, "");
6490   return 1;
6491 }
6492
6493 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6494    INDENT should be zero when called from the top level; it is
6495    incremented recursively.  IGO indicates the next expected BINFO in
6496    inheritance graph ordering.  */
6497
6498 static tree
6499 dump_class_hierarchy_r (FILE *stream,
6500                         int flags,
6501                         tree binfo,
6502                         tree igo,
6503                         int indent)
6504 {
6505   int indented = 0;
6506   tree base_binfo;
6507   int i;
6508
6509   indented = maybe_indent_hierarchy (stream, indent, 0);
6510   fprintf (stream, "%s (0x%lx) ",
6511            type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6512            (unsigned long) binfo);
6513   if (binfo != igo)
6514     {
6515       fprintf (stream, "alternative-path\n");
6516       return igo;
6517     }
6518   igo = TREE_CHAIN (binfo);
6519
6520   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6521            tree_low_cst (BINFO_OFFSET (binfo), 0));
6522   if (is_empty_class (BINFO_TYPE (binfo)))
6523     fprintf (stream, " empty");
6524   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6525     fprintf (stream, " nearly-empty");
6526   if (BINFO_VIRTUAL_P (binfo))
6527     fprintf (stream, " virtual");
6528   fprintf (stream, "\n");
6529
6530   indented = 0;
6531   if (BINFO_PRIMARY_P (binfo))
6532     {
6533       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6534       fprintf (stream, " primary-for %s (0x%lx)",
6535                type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
6536                                TFF_PLAIN_IDENTIFIER),
6537                (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
6538     }
6539   if (BINFO_LOST_PRIMARY_P (binfo))
6540     {
6541       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6542       fprintf (stream, " lost-primary");
6543     }
6544   if (indented)
6545     fprintf (stream, "\n");
6546
6547   if (!(flags & TDF_SLIM))
6548     {
6549       int indented = 0;
6550
6551       if (BINFO_SUBVTT_INDEX (binfo))
6552         {
6553           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6554           fprintf (stream, " subvttidx=%s",
6555                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6556                                    TFF_PLAIN_IDENTIFIER));
6557         }
6558       if (BINFO_VPTR_INDEX (binfo))
6559         {
6560           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6561           fprintf (stream, " vptridx=%s",
6562                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6563                                    TFF_PLAIN_IDENTIFIER));
6564         }
6565       if (BINFO_VPTR_FIELD (binfo))
6566         {
6567           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6568           fprintf (stream, " vbaseoffset=%s",
6569                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6570                                    TFF_PLAIN_IDENTIFIER));
6571         }
6572       if (BINFO_VTABLE (binfo))
6573         {
6574           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6575           fprintf (stream, " vptr=%s",
6576                    expr_as_string (BINFO_VTABLE (binfo),
6577                                    TFF_PLAIN_IDENTIFIER));
6578         }
6579
6580       if (indented)
6581         fprintf (stream, "\n");
6582     }
6583
6584   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
6585     igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
6586
6587   return igo;
6588 }
6589
6590 /* Dump the BINFO hierarchy for T.  */
6591
6592 static void
6593 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6594 {
6595   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6596   fprintf (stream, "   size=%lu align=%lu\n",
6597            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6598            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6599   fprintf (stream, "   base size=%lu base align=%lu\n",
6600            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6601                            / BITS_PER_UNIT),
6602            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6603                            / BITS_PER_UNIT));
6604   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6605   fprintf (stream, "\n");
6606 }
6607
6608 /* Debug interface to hierarchy dumping.  */
6609
6610 void
6611 debug_class (tree t)
6612 {
6613   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6614 }
6615
6616 static void
6617 dump_class_hierarchy (tree t)
6618 {
6619   int flags;
6620   FILE *stream = dump_begin (TDI_class, &flags);
6621
6622   if (stream)
6623     {
6624       dump_class_hierarchy_1 (stream, flags, t);
6625       dump_end (TDI_class, stream);
6626     }
6627 }
6628
6629 static void
6630 dump_array (FILE * stream, tree decl)
6631 {
6632   tree value;
6633   unsigned HOST_WIDE_INT ix;
6634   HOST_WIDE_INT elt;
6635   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6636
6637   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6638          / BITS_PER_UNIT);
6639   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6640   fprintf (stream, " %s entries",
6641            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6642                            TFF_PLAIN_IDENTIFIER));
6643   fprintf (stream, "\n");
6644
6645   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
6646                               ix, value)
6647     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6648              expr_as_string (value, TFF_PLAIN_IDENTIFIER));
6649 }
6650
6651 static void
6652 dump_vtable (tree t, tree binfo, tree vtable)
6653 {
6654   int flags;
6655   FILE *stream = dump_begin (TDI_class, &flags);
6656
6657   if (!stream)
6658     return;
6659
6660   if (!(flags & TDF_SLIM))
6661     {
6662       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6663
6664       fprintf (stream, "%s for %s",
6665                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6666                type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
6667       if (ctor_vtbl_p)
6668         {
6669           if (!BINFO_VIRTUAL_P (binfo))
6670             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6671           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6672         }
6673       fprintf (stream, "\n");
6674       dump_array (stream, vtable);
6675       fprintf (stream, "\n");
6676     }
6677
6678   dump_end (TDI_class, stream);
6679 }
6680
6681 static void
6682 dump_vtt (tree t, tree vtt)
6683 {
6684   int flags;
6685   FILE *stream = dump_begin (TDI_class, &flags);
6686
6687   if (!stream)
6688     return;
6689
6690   if (!(flags & TDF_SLIM))
6691     {
6692       fprintf (stream, "VTT for %s\n",
6693                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6694       dump_array (stream, vtt);
6695       fprintf (stream, "\n");
6696     }
6697
6698   dump_end (TDI_class, stream);
6699 }
6700
6701 /* Dump a function or thunk and its thunkees.  */
6702
6703 static void
6704 dump_thunk (FILE *stream, int indent, tree thunk)
6705 {
6706   static const char spaces[] = "        ";
6707   tree name = DECL_NAME (thunk);
6708   tree thunks;
6709
6710   fprintf (stream, "%.*s%p %s %s", indent, spaces,
6711            (void *)thunk,
6712            !DECL_THUNK_P (thunk) ? "function"
6713            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6714            name ? IDENTIFIER_POINTER (name) : "<unset>");
6715   if (DECL_THUNK_P (thunk))
6716     {
6717       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6718       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6719
6720       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6721       if (!virtual_adjust)
6722         /*NOP*/;
6723       else if (DECL_THIS_THUNK_P (thunk))
6724         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
6725                  tree_low_cst (virtual_adjust, 0));
6726       else
6727         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6728                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6729                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6730       if (THUNK_ALIAS (thunk))
6731         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6732     }
6733   fprintf (stream, "\n");
6734   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6735     dump_thunk (stream, indent + 2, thunks);
6736 }
6737
6738 /* Dump the thunks for FN.  */
6739
6740 void
6741 debug_thunks (tree fn)
6742 {
6743   dump_thunk (stderr, 0, fn);
6744 }
6745
6746 /* Virtual function table initialization.  */
6747
6748 /* Create all the necessary vtables for T and its base classes.  */
6749
6750 static void
6751 finish_vtbls (tree t)
6752 {
6753   tree list;
6754   tree vbase;
6755
6756   /* We lay out the primary and secondary vtables in one contiguous
6757      vtable.  The primary vtable is first, followed by the non-virtual
6758      secondary vtables in inheritance graph order.  */
6759   list = build_tree_list (BINFO_VTABLE (TYPE_BINFO (t)), NULL_TREE);
6760   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6761                          TYPE_BINFO (t), t, list);
6762
6763   /* Then come the virtual bases, also in inheritance graph order.  */
6764   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6765     {
6766       if (!BINFO_VIRTUAL_P (vbase))
6767         continue;
6768       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6769     }
6770
6771   if (BINFO_VTABLE (TYPE_BINFO (t)))
6772     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6773 }
6774
6775 /* Initialize the vtable for BINFO with the INITS.  */
6776
6777 static void
6778 initialize_vtable (tree binfo, tree inits)
6779 {
6780   tree decl;
6781
6782   layout_vtable_decl (binfo, list_length (inits));
6783   decl = get_vtbl_decl_for_binfo (binfo);
6784   initialize_artificial_var (decl, inits);
6785   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6786 }
6787
6788 /* Build the VTT (virtual table table) for T.
6789    A class requires a VTT if it has virtual bases.
6790
6791    This holds
6792    1 - primary virtual pointer for complete object T
6793    2 - secondary VTTs for each direct non-virtual base of T which requires a
6794        VTT
6795    3 - secondary virtual pointers for each direct or indirect base of T which
6796        has virtual bases or is reachable via a virtual path from T.
6797    4 - secondary VTTs for each direct or indirect virtual base of T.
6798
6799    Secondary VTTs look like complete object VTTs without part 4.  */
6800
6801 static void
6802 build_vtt (tree t)
6803 {
6804   tree inits;
6805   tree type;
6806   tree vtt;
6807   tree index;
6808
6809   /* Build up the initializers for the VTT.  */
6810   inits = NULL_TREE;
6811   index = size_zero_node;
6812   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6813
6814   /* If we didn't need a VTT, we're done.  */
6815   if (!inits)
6816     return;
6817
6818   /* Figure out the type of the VTT.  */
6819   type = build_index_type (size_int (list_length (inits) - 1));
6820   type = build_cplus_array_type (const_ptr_type_node, type);
6821
6822   /* Now, build the VTT object itself.  */
6823   vtt = build_vtable (t, mangle_vtt_for_type (t), type);
6824   initialize_artificial_var (vtt, inits);
6825   /* Add the VTT to the vtables list.  */
6826   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6827   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6828
6829   dump_vtt (t, vtt);
6830 }
6831
6832 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6833    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6834    and CHAIN the vtable pointer for this binfo after construction is
6835    complete.  VALUE can also be another BINFO, in which case we recurse.  */
6836
6837 static tree
6838 binfo_ctor_vtable (tree binfo)
6839 {
6840   tree vt;
6841
6842   while (1)
6843     {
6844       vt = BINFO_VTABLE (binfo);
6845       if (TREE_CODE (vt) == TREE_LIST)
6846         vt = TREE_VALUE (vt);
6847       if (TREE_CODE (vt) == TREE_BINFO)
6848         binfo = vt;
6849       else
6850         break;
6851     }
6852
6853   return vt;
6854 }
6855
6856 /* Data for secondary VTT initialization.  */
6857 typedef struct secondary_vptr_vtt_init_data_s
6858 {
6859   /* Is this the primary VTT? */
6860   bool top_level_p;
6861
6862   /* Current index into the VTT.  */
6863   tree index;
6864
6865   /* TREE_LIST of initializers built up.  */
6866   tree inits;
6867
6868   /* The type being constructed by this secondary VTT.  */
6869   tree type_being_constructed;
6870 } secondary_vptr_vtt_init_data;
6871
6872 /* Recursively build the VTT-initializer for BINFO (which is in the
6873    hierarchy dominated by T).  INITS points to the end of the initializer
6874    list to date.  INDEX is the VTT index where the next element will be
6875    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6876    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
6877    for virtual bases of T. When it is not so, we build the constructor
6878    vtables for the BINFO-in-T variant.  */
6879
6880 static tree *
6881 build_vtt_inits (tree binfo, tree t, tree *inits, tree *index)
6882 {
6883   int i;
6884   tree b;
6885   tree init;
6886   tree secondary_vptrs;
6887   secondary_vptr_vtt_init_data data;
6888   int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
6889
6890   /* We only need VTTs for subobjects with virtual bases.  */
6891   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
6892     return inits;
6893
6894   /* We need to use a construction vtable if this is not the primary
6895      VTT.  */
6896   if (!top_level_p)
6897     {
6898       build_ctor_vtbl_group (binfo, t);
6899
6900       /* Record the offset in the VTT where this sub-VTT can be found.  */
6901       BINFO_SUBVTT_INDEX (binfo) = *index;
6902     }
6903
6904   /* Add the address of the primary vtable for the complete object.  */
6905   init = binfo_ctor_vtable (binfo);
6906   *inits = build_tree_list (NULL_TREE, init);
6907   inits = &TREE_CHAIN (*inits);
6908   if (top_level_p)
6909     {
6910       gcc_assert (!BINFO_VPTR_INDEX (binfo));
6911       BINFO_VPTR_INDEX (binfo) = *index;
6912     }
6913   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
6914
6915   /* Recursively add the secondary VTTs for non-virtual bases.  */
6916   for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
6917     if (!BINFO_VIRTUAL_P (b))
6918       inits = build_vtt_inits (b, t, inits, index);
6919
6920   /* Add secondary virtual pointers for all subobjects of BINFO with
6921      either virtual bases or reachable along a virtual path, except
6922      subobjects that are non-virtual primary bases.  */
6923   data.top_level_p = top_level_p;
6924   data.index = *index;
6925   data.inits = NULL;
6926   data.type_being_constructed = BINFO_TYPE (binfo);
6927
6928   dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
6929
6930   *index = data.index;
6931
6932   /* The secondary vptrs come back in reverse order.  After we reverse
6933      them, and add the INITS, the last init will be the first element
6934      of the chain.  */
6935   secondary_vptrs = data.inits;
6936   if (secondary_vptrs)
6937     {
6938       *inits = nreverse (secondary_vptrs);
6939       inits = &TREE_CHAIN (secondary_vptrs);
6940       gcc_assert (*inits == NULL_TREE);
6941     }
6942
6943   if (top_level_p)
6944     /* Add the secondary VTTs for virtual bases in inheritance graph
6945        order.  */
6946     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
6947       {
6948         if (!BINFO_VIRTUAL_P (b))
6949           continue;
6950
6951         inits = build_vtt_inits (b, t, inits, index);
6952       }
6953   else
6954     /* Remove the ctor vtables we created.  */
6955     dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
6956
6957   return inits;
6958 }
6959
6960 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo for the base
6961    in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure.  */
6962
6963 static tree
6964 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
6965 {
6966   secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
6967
6968   /* We don't care about bases that don't have vtables.  */
6969   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
6970     return dfs_skip_bases;
6971
6972   /* We're only interested in proper subobjects of the type being
6973      constructed.  */
6974   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
6975     return NULL_TREE;
6976
6977   /* We're only interested in bases with virtual bases or reachable
6978      via a virtual path from the type being constructed.  */
6979   if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
6980         || binfo_via_virtual (binfo, data->type_being_constructed)))
6981     return dfs_skip_bases;
6982
6983   /* We're not interested in non-virtual primary bases.  */
6984   if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
6985     return NULL_TREE;
6986
6987   /* Record the index where this secondary vptr can be found.  */
6988   if (data->top_level_p)
6989     {
6990       gcc_assert (!BINFO_VPTR_INDEX (binfo));
6991       BINFO_VPTR_INDEX (binfo) = data->index;
6992
6993       if (BINFO_VIRTUAL_P (binfo))
6994         {
6995           /* It's a primary virtual base, and this is not a
6996              construction vtable.  Find the base this is primary of in
6997              the inheritance graph, and use that base's vtable
6998              now.  */
6999           while (BINFO_PRIMARY_P (binfo))
7000             binfo = BINFO_INHERITANCE_CHAIN (binfo);
7001         }
7002     }
7003
7004   /* Add the initializer for the secondary vptr itself.  */
7005   data->inits = tree_cons (NULL_TREE, binfo_ctor_vtable (binfo), data->inits);
7006
7007   /* Advance the vtt index.  */
7008   data->index = size_binop (PLUS_EXPR, data->index,
7009                             TYPE_SIZE_UNIT (ptr_type_node));
7010
7011   return NULL_TREE;
7012 }
7013
7014 /* Called from build_vtt_inits via dfs_walk. After building
7015    constructor vtables and generating the sub-vtt from them, we need
7016    to restore the BINFO_VTABLES that were scribbled on.  DATA is the
7017    binfo of the base whose sub vtt was generated.  */
7018
7019 static tree
7020 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7021 {
7022   tree vtable = BINFO_VTABLE (binfo);
7023
7024   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7025     /* If this class has no vtable, none of its bases do.  */
7026     return dfs_skip_bases;
7027
7028   if (!vtable)
7029     /* This might be a primary base, so have no vtable in this
7030        hierarchy.  */
7031     return NULL_TREE;
7032
7033   /* If we scribbled the construction vtable vptr into BINFO, clear it
7034      out now.  */
7035   if (TREE_CODE (vtable) == TREE_LIST
7036       && (TREE_PURPOSE (vtable) == (tree) data))
7037     BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
7038
7039   return NULL_TREE;
7040 }
7041
7042 /* Build the construction vtable group for BINFO which is in the
7043    hierarchy dominated by T.  */
7044
7045 static void
7046 build_ctor_vtbl_group (tree binfo, tree t)
7047 {
7048   tree list;
7049   tree type;
7050   tree vtbl;
7051   tree inits;
7052   tree id;
7053   tree vbase;
7054
7055   /* See if we've already created this construction vtable group.  */
7056   id = mangle_ctor_vtbl_for_type (t, binfo);
7057   if (IDENTIFIER_GLOBAL_VALUE (id))
7058     return;
7059
7060   gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
7061   /* Build a version of VTBL (with the wrong type) for use in
7062      constructing the addresses of secondary vtables in the
7063      construction vtable group.  */
7064   vtbl = build_vtable (t, id, ptr_type_node);
7065   DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
7066   list = build_tree_list (vtbl, NULL_TREE);
7067   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7068                          binfo, t, list);
7069
7070   /* Add the vtables for each of our virtual bases using the vbase in T
7071      binfo.  */
7072   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7073        vbase;
7074        vbase = TREE_CHAIN (vbase))
7075     {
7076       tree b;
7077
7078       if (!BINFO_VIRTUAL_P (vbase))
7079         continue;
7080       b = copied_binfo (vbase, binfo);
7081
7082       accumulate_vtbl_inits (b, vbase, binfo, t, list);
7083     }
7084   inits = TREE_VALUE (list);
7085
7086   /* Figure out the type of the construction vtable.  */
7087   type = build_index_type (size_int (list_length (inits) - 1));
7088   type = build_cplus_array_type (vtable_entry_type, type);
7089   layout_type (type);
7090   TREE_TYPE (vtbl) = type;
7091   DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE;
7092   layout_decl (vtbl, 0);
7093
7094   /* Initialize the construction vtable.  */
7095   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7096   initialize_artificial_var (vtbl, inits);
7097   dump_vtable (t, binfo, vtbl);
7098 }
7099
7100 /* Add the vtbl initializers for BINFO (and its bases other than
7101    non-virtual primaries) to the list of INITS.  BINFO is in the
7102    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
7103    the constructor the vtbl inits should be accumulated for. (If this
7104    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7105    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7106    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7107    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7108    but are not necessarily the same in terms of layout.  */
7109
7110 static void
7111 accumulate_vtbl_inits (tree binfo,
7112                        tree orig_binfo,
7113                        tree rtti_binfo,
7114                        tree t,
7115                        tree inits)
7116 {
7117   int i;
7118   tree base_binfo;
7119   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7120
7121   gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
7122
7123   /* If it doesn't have a vptr, we don't do anything.  */
7124   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7125     return;
7126
7127   /* If we're building a construction vtable, we're not interested in
7128      subobjects that don't require construction vtables.  */
7129   if (ctor_vtbl_p
7130       && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7131       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7132     return;
7133
7134   /* Build the initializers for the BINFO-in-T vtable.  */
7135   TREE_VALUE (inits)
7136     = chainon (TREE_VALUE (inits),
7137                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7138                                           rtti_binfo, t, inits));
7139
7140   /* Walk the BINFO and its bases.  We walk in preorder so that as we
7141      initialize each vtable we can figure out at what offset the
7142      secondary vtable lies from the primary vtable.  We can't use
7143      dfs_walk here because we need to iterate through bases of BINFO
7144      and RTTI_BINFO simultaneously.  */
7145   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7146     {
7147       /* Skip virtual bases.  */
7148       if (BINFO_VIRTUAL_P (base_binfo))
7149         continue;
7150       accumulate_vtbl_inits (base_binfo,
7151                              BINFO_BASE_BINFO (orig_binfo, i),
7152                              rtti_binfo, t,
7153                              inits);
7154     }
7155 }
7156
7157 /* Called from accumulate_vtbl_inits.  Returns the initializers for
7158    the BINFO vtable.  */
7159
7160 static tree
7161 dfs_accumulate_vtbl_inits (tree binfo,
7162                            tree orig_binfo,
7163                            tree rtti_binfo,
7164                            tree t,
7165                            tree l)
7166 {
7167   tree inits = NULL_TREE;
7168   tree vtbl = NULL_TREE;
7169   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7170
7171   if (ctor_vtbl_p
7172       && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7173     {
7174       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7175          primary virtual base.  If it is not the same primary in
7176          the hierarchy of T, we'll need to generate a ctor vtable
7177          for it, to place at its location in T.  If it is the same
7178          primary, we still need a VTT entry for the vtable, but it
7179          should point to the ctor vtable for the base it is a
7180          primary for within the sub-hierarchy of RTTI_BINFO.
7181
7182          There are three possible cases:
7183
7184          1) We are in the same place.
7185          2) We are a primary base within a lost primary virtual base of
7186          RTTI_BINFO.
7187          3) We are primary to something not a base of RTTI_BINFO.  */
7188
7189       tree b;
7190       tree last = NULL_TREE;
7191
7192       /* First, look through the bases we are primary to for RTTI_BINFO
7193          or a virtual base.  */
7194       b = binfo;
7195       while (BINFO_PRIMARY_P (b))
7196         {
7197           b = BINFO_INHERITANCE_CHAIN (b);
7198           last = b;
7199           if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7200             goto found;
7201         }
7202       /* If we run out of primary links, keep looking down our
7203          inheritance chain; we might be an indirect primary.  */
7204       for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7205         if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7206           break;
7207     found:
7208
7209       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7210          base B and it is a base of RTTI_BINFO, this is case 2.  In
7211          either case, we share our vtable with LAST, i.e. the
7212          derived-most base within B of which we are a primary.  */
7213       if (b == rtti_binfo
7214           || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7215         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7216            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7217            binfo_ctor_vtable after everything's been set up.  */
7218         vtbl = last;
7219
7220       /* Otherwise, this is case 3 and we get our own.  */
7221     }
7222   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7223     return inits;
7224
7225   if (!vtbl)
7226     {
7227       tree index;
7228       int non_fn_entries;
7229
7230       /* Compute the initializer for this vtable.  */
7231       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7232                                       &non_fn_entries);
7233
7234       /* Figure out the position to which the VPTR should point.  */
7235       vtbl = TREE_PURPOSE (l);
7236       vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, vtbl);
7237       index = size_binop (PLUS_EXPR,
7238                           size_int (non_fn_entries),
7239                           size_int (list_length (TREE_VALUE (l))));
7240       index = size_binop (MULT_EXPR,
7241                           TYPE_SIZE_UNIT (vtable_entry_type),
7242                           index);
7243       vtbl = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7244     }
7245
7246   if (ctor_vtbl_p)
7247     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7248        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7249        straighten this out.  */
7250     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7251   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7252     inits = NULL_TREE;
7253   else
7254      /* For an ordinary vtable, set BINFO_VTABLE.  */
7255     BINFO_VTABLE (binfo) = vtbl;
7256
7257   return inits;
7258 }
7259
7260 static GTY(()) tree abort_fndecl_addr;
7261
7262 /* Construct the initializer for BINFO's virtual function table.  BINFO
7263    is part of the hierarchy dominated by T.  If we're building a
7264    construction vtable, the ORIG_BINFO is the binfo we should use to
7265    find the actual function pointers to put in the vtable - but they
7266    can be overridden on the path to most-derived in the graph that
7267    ORIG_BINFO belongs.  Otherwise,
7268    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7269    BINFO that should be indicated by the RTTI information in the
7270    vtable; it will be a base class of T, rather than T itself, if we
7271    are building a construction vtable.
7272
7273    The value returned is a TREE_LIST suitable for wrapping in a
7274    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7275    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7276    number of non-function entries in the vtable.
7277
7278    It might seem that this function should never be called with a
7279    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7280    base is always subsumed by a derived class vtable.  However, when
7281    we are building construction vtables, we do build vtables for
7282    primary bases; we need these while the primary base is being
7283    constructed.  */
7284
7285 static tree
7286 build_vtbl_initializer (tree binfo,
7287                         tree orig_binfo,
7288                         tree t,
7289                         tree rtti_binfo,
7290                         int* non_fn_entries_p)
7291 {
7292   tree v, b;
7293   tree vfun_inits;
7294   vtbl_init_data vid;
7295   unsigned ix;
7296   tree vbinfo;
7297   VEC(tree,gc) *vbases;
7298
7299   /* Initialize VID.  */
7300   memset (&vid, 0, sizeof (vid));
7301   vid.binfo = binfo;
7302   vid.derived = t;
7303   vid.rtti_binfo = rtti_binfo;
7304   vid.last_init = &vid.inits;
7305   vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7306   vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7307   vid.generate_vcall_entries = true;
7308   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7309   vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7310
7311   /* Add entries to the vtable for RTTI.  */
7312   build_rtti_vtbl_entries (binfo, &vid);
7313
7314   /* Create an array for keeping track of the functions we've
7315      processed.  When we see multiple functions with the same
7316      signature, we share the vcall offsets.  */
7317   vid.fns = VEC_alloc (tree, gc, 32);
7318   /* Add the vcall and vbase offset entries.  */
7319   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7320
7321   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7322      build_vbase_offset_vtbl_entries.  */
7323   for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7324        VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7325     BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7326
7327   /* If the target requires padding between data entries, add that now.  */
7328   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7329     {
7330       tree cur, *prev;
7331
7332       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7333         {
7334           tree add = cur;
7335           int i;
7336
7337           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7338             add = tree_cons (NULL_TREE,
7339                              build1 (NOP_EXPR, vtable_entry_type,
7340                                      null_pointer_node),
7341                              add);
7342           *prev = add;
7343         }
7344     }
7345
7346   if (non_fn_entries_p)
7347     *non_fn_entries_p = list_length (vid.inits);
7348
7349   /* Go through all the ordinary virtual functions, building up
7350      initializers.  */
7351   vfun_inits = NULL_TREE;
7352   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7353     {
7354       tree delta;
7355       tree vcall_index;
7356       tree fn, fn_original;
7357       tree init = NULL_TREE;
7358
7359       fn = BV_FN (v);
7360       fn_original = fn;
7361       if (DECL_THUNK_P (fn))
7362         {
7363           if (!DECL_NAME (fn))
7364             finish_thunk (fn);
7365           if (THUNK_ALIAS (fn))
7366             {
7367               fn = THUNK_ALIAS (fn);
7368               BV_FN (v) = fn;
7369             }
7370           fn_original = THUNK_TARGET (fn);
7371         }
7372
7373       /* If the only definition of this function signature along our
7374          primary base chain is from a lost primary, this vtable slot will
7375          never be used, so just zero it out.  This is important to avoid
7376          requiring extra thunks which cannot be generated with the function.
7377
7378          We first check this in update_vtable_entry_for_fn, so we handle
7379          restored primary bases properly; we also need to do it here so we
7380          zero out unused slots in ctor vtables, rather than filling themff
7381          with erroneous values (though harmless, apart from relocation
7382          costs).  */
7383       for (b = binfo; ; b = get_primary_binfo (b))
7384         {
7385           /* We found a defn before a lost primary; go ahead as normal.  */
7386           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7387             break;
7388
7389           /* The nearest definition is from a lost primary; clear the
7390              slot.  */
7391           if (BINFO_LOST_PRIMARY_P (b))
7392             {
7393               init = size_zero_node;
7394               break;
7395             }
7396         }
7397
7398       if (! init)
7399         {
7400           /* Pull the offset for `this', and the function to call, out of
7401              the list.  */
7402           delta = BV_DELTA (v);
7403           vcall_index = BV_VCALL_INDEX (v);
7404
7405           gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7406           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7407
7408           /* You can't call an abstract virtual function; it's abstract.
7409              So, we replace these functions with __pure_virtual.  */
7410           if (DECL_PURE_VIRTUAL_P (fn_original))
7411             {
7412               fn = abort_fndecl;
7413               if (abort_fndecl_addr == NULL)
7414                 abort_fndecl_addr = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7415               init = abort_fndecl_addr;
7416             }
7417           else
7418             {
7419               if (!integer_zerop (delta) || vcall_index)
7420                 {
7421                   fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7422                   if (!DECL_NAME (fn))
7423                     finish_thunk (fn);
7424                 }
7425               /* Take the address of the function, considering it to be of an
7426                  appropriate generic type.  */
7427               init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7428             }
7429         }
7430
7431       /* And add it to the chain of initializers.  */
7432       if (TARGET_VTABLE_USES_DESCRIPTORS)
7433         {
7434           int i;
7435           if (init == size_zero_node)
7436             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7437               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7438           else
7439             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7440               {
7441                 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7442                                      TREE_OPERAND (init, 0),
7443                                      build_int_cst (NULL_TREE, i));
7444                 TREE_CONSTANT (fdesc) = 1;
7445                 TREE_INVARIANT (fdesc) = 1;
7446
7447                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7448               }
7449         }
7450       else
7451         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7452     }
7453
7454   /* The initializers for virtual functions were built up in reverse
7455      order; straighten them out now.  */
7456   vfun_inits = nreverse (vfun_inits);
7457
7458   /* The negative offset initializers are also in reverse order.  */
7459   vid.inits = nreverse (vid.inits);
7460
7461   /* Chain the two together.  */
7462   return chainon (vid.inits, vfun_inits);
7463 }
7464
7465 /* Adds to vid->inits the initializers for the vbase and vcall
7466    offsets in BINFO, which is in the hierarchy dominated by T.  */
7467
7468 static void
7469 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7470 {
7471   tree b;
7472
7473   /* If this is a derived class, we must first create entries
7474      corresponding to the primary base class.  */
7475   b = get_primary_binfo (binfo);
7476   if (b)
7477     build_vcall_and_vbase_vtbl_entries (b, vid);
7478
7479   /* Add the vbase entries for this base.  */
7480   build_vbase_offset_vtbl_entries (binfo, vid);
7481   /* Add the vcall entries for this base.  */
7482   build_vcall_offset_vtbl_entries (binfo, vid);
7483 }
7484
7485 /* Returns the initializers for the vbase offset entries in the vtable
7486    for BINFO (which is part of the class hierarchy dominated by T), in
7487    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7488    where the next vbase offset will go.  */
7489
7490 static void
7491 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7492 {
7493   tree vbase;
7494   tree t;
7495   tree non_primary_binfo;
7496
7497   /* If there are no virtual baseclasses, then there is nothing to
7498      do.  */
7499   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7500     return;
7501
7502   t = vid->derived;
7503
7504   /* We might be a primary base class.  Go up the inheritance hierarchy
7505      until we find the most derived class of which we are a primary base:
7506      it is the offset of that which we need to use.  */
7507   non_primary_binfo = binfo;
7508   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7509     {
7510       tree b;
7511
7512       /* If we have reached a virtual base, then it must be a primary
7513          base (possibly multi-level) of vid->binfo, or we wouldn't
7514          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7515          might be a lost primary, so just skip down to vid->binfo.  */
7516       if (BINFO_VIRTUAL_P (non_primary_binfo))
7517         {
7518           non_primary_binfo = vid->binfo;
7519           break;
7520         }
7521
7522       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7523       if (get_primary_binfo (b) != non_primary_binfo)
7524         break;
7525       non_primary_binfo = b;
7526     }
7527
7528   /* Go through the virtual bases, adding the offsets.  */
7529   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7530        vbase;
7531        vbase = TREE_CHAIN (vbase))
7532     {
7533       tree b;
7534       tree delta;
7535
7536       if (!BINFO_VIRTUAL_P (vbase))
7537         continue;
7538
7539       /* Find the instance of this virtual base in the complete
7540          object.  */
7541       b = copied_binfo (vbase, binfo);
7542
7543       /* If we've already got an offset for this virtual base, we
7544          don't need another one.  */
7545       if (BINFO_VTABLE_PATH_MARKED (b))
7546         continue;
7547       BINFO_VTABLE_PATH_MARKED (b) = 1;
7548
7549       /* Figure out where we can find this vbase offset.  */
7550       delta = size_binop (MULT_EXPR,
7551                           vid->index,
7552                           convert (ssizetype,
7553                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7554       if (vid->primary_vtbl_p)
7555         BINFO_VPTR_FIELD (b) = delta;
7556
7557       if (binfo != TYPE_BINFO (t))
7558         /* The vbase offset had better be the same.  */
7559         gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
7560
7561       /* The next vbase will come at a more negative offset.  */
7562       vid->index = size_binop (MINUS_EXPR, vid->index,
7563                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7564
7565       /* The initializer is the delta from BINFO to this virtual base.
7566          The vbase offsets go in reverse inheritance-graph order, and
7567          we are walking in inheritance graph order so these end up in
7568          the right order.  */
7569       delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7570
7571       *vid->last_init
7572         = build_tree_list (NULL_TREE,
7573                            fold_build1 (NOP_EXPR,
7574                                         vtable_entry_type,
7575                                         delta));
7576       vid->last_init = &TREE_CHAIN (*vid->last_init);
7577     }
7578 }
7579
7580 /* Adds the initializers for the vcall offset entries in the vtable
7581    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7582    to VID->INITS.  */
7583
7584 static void
7585 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7586 {
7587   /* We only need these entries if this base is a virtual base.  We
7588      compute the indices -- but do not add to the vtable -- when
7589      building the main vtable for a class.  */
7590   if (binfo == TYPE_BINFO (vid->derived)
7591       || (BINFO_VIRTUAL_P (binfo)
7592           /* If BINFO is RTTI_BINFO, then (since BINFO does not
7593              correspond to VID->DERIVED), we are building a primary
7594              construction virtual table.  Since this is a primary
7595              virtual table, we do not need the vcall offsets for
7596              BINFO.  */
7597           && binfo != vid->rtti_binfo))
7598     {
7599       /* We need a vcall offset for each of the virtual functions in this
7600          vtable.  For example:
7601
7602            class A { virtual void f (); };
7603            class B1 : virtual public A { virtual void f (); };
7604            class B2 : virtual public A { virtual void f (); };
7605            class C: public B1, public B2 { virtual void f (); };
7606
7607          A C object has a primary base of B1, which has a primary base of A.  A
7608          C also has a secondary base of B2, which no longer has a primary base
7609          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7610          A, which will adjust the A* to a B2* to call f.  We have no way of
7611          knowing what (or even whether) this offset will be when we define B2,
7612          so we store this "vcall offset" in the A sub-vtable and look it up in
7613          a "virtual thunk" for B2::f.
7614
7615          We need entries for all the functions in our primary vtable and
7616          in our non-virtual bases' secondary vtables.  */
7617       vid->vbase = binfo;
7618       /* If we are just computing the vcall indices -- but do not need
7619          the actual entries -- not that.  */
7620       if (!BINFO_VIRTUAL_P (binfo))
7621         vid->generate_vcall_entries = false;
7622       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7623       add_vcall_offset_vtbl_entries_r (binfo, vid);
7624     }
7625 }
7626
7627 /* Build vcall offsets, starting with those for BINFO.  */
7628
7629 static void
7630 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7631 {
7632   int i;
7633   tree primary_binfo;
7634   tree base_binfo;
7635
7636   /* Don't walk into virtual bases -- except, of course, for the
7637      virtual base for which we are building vcall offsets.  Any
7638      primary virtual base will have already had its offsets generated
7639      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7640   if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
7641     return;
7642
7643   /* If BINFO has a primary base, process it first.  */
7644   primary_binfo = get_primary_binfo (binfo);
7645   if (primary_binfo)
7646     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7647
7648   /* Add BINFO itself to the list.  */
7649   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7650
7651   /* Scan the non-primary bases of BINFO.  */
7652   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7653     if (base_binfo != primary_binfo)
7654       add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7655 }
7656
7657 /* Called from build_vcall_offset_vtbl_entries_r.  */
7658
7659 static void
7660 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7661 {
7662   /* Make entries for the rest of the virtuals.  */
7663   if (abi_version_at_least (2))
7664     {
7665       tree orig_fn;
7666
7667       /* The ABI requires that the methods be processed in declaration
7668          order.  G++ 3.2 used the order in the vtable.  */
7669       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7670            orig_fn;
7671            orig_fn = TREE_CHAIN (orig_fn))
7672         if (DECL_VINDEX (orig_fn))
7673           add_vcall_offset (orig_fn, binfo, vid);
7674     }
7675   else
7676     {
7677       tree derived_virtuals;
7678       tree base_virtuals;
7679       tree orig_virtuals;
7680       /* If BINFO is a primary base, the most derived class which has
7681          BINFO as a primary base; otherwise, just BINFO.  */
7682       tree non_primary_binfo;
7683
7684       /* We might be a primary base class.  Go up the inheritance hierarchy
7685          until we find the most derived class of which we are a primary base:
7686          it is the BINFO_VIRTUALS there that we need to consider.  */
7687       non_primary_binfo = binfo;
7688       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7689         {
7690           tree b;
7691
7692           /* If we have reached a virtual base, then it must be vid->vbase,
7693              because we ignore other virtual bases in
7694              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7695              base (possibly multi-level) of vid->binfo, or we wouldn't
7696              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7697              might be a lost primary, so just skip down to vid->binfo.  */
7698           if (BINFO_VIRTUAL_P (non_primary_binfo))
7699             {
7700               gcc_assert (non_primary_binfo == vid->vbase);
7701               non_primary_binfo = vid->binfo;
7702               break;
7703             }
7704
7705           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7706           if (get_primary_binfo (b) != non_primary_binfo)
7707             break;
7708           non_primary_binfo = b;
7709         }
7710
7711       if (vid->ctor_vtbl_p)
7712         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7713            where rtti_binfo is the most derived type.  */
7714         non_primary_binfo
7715           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7716
7717       for (base_virtuals = BINFO_VIRTUALS (binfo),
7718              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7719              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7720            base_virtuals;
7721            base_virtuals = TREE_CHAIN (base_virtuals),
7722              derived_virtuals = TREE_CHAIN (derived_virtuals),
7723              orig_virtuals = TREE_CHAIN (orig_virtuals))
7724         {
7725           tree orig_fn;
7726
7727           /* Find the declaration that originally caused this function to
7728              be present in BINFO_TYPE (binfo).  */
7729           orig_fn = BV_FN (orig_virtuals);
7730
7731           /* When processing BINFO, we only want to generate vcall slots for
7732              function slots introduced in BINFO.  So don't try to generate
7733              one if the function isn't even defined in BINFO.  */
7734           if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
7735             continue;
7736
7737           add_vcall_offset (orig_fn, binfo, vid);
7738         }
7739     }
7740 }
7741
7742 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7743
7744 static void
7745 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7746 {
7747   size_t i;
7748   tree vcall_offset;
7749   tree derived_entry;
7750
7751   /* If there is already an entry for a function with the same
7752      signature as FN, then we do not need a second vcall offset.
7753      Check the list of functions already present in the derived
7754      class vtable.  */
7755   for (i = 0; VEC_iterate (tree, vid->fns, i, derived_entry); ++i)
7756     {
7757       if (same_signature_p (derived_entry, orig_fn)
7758           /* We only use one vcall offset for virtual destructors,
7759              even though there are two virtual table entries.  */
7760           || (DECL_DESTRUCTOR_P (derived_entry)
7761               && DECL_DESTRUCTOR_P (orig_fn)))
7762         return;
7763     }
7764
7765   /* If we are building these vcall offsets as part of building
7766      the vtable for the most derived class, remember the vcall
7767      offset.  */
7768   if (vid->binfo == TYPE_BINFO (vid->derived))
7769     {
7770       tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
7771                                        CLASSTYPE_VCALL_INDICES (vid->derived),
7772                                        NULL);
7773       elt->purpose = orig_fn;
7774       elt->value = vid->index;
7775     }
7776
7777   /* The next vcall offset will be found at a more negative
7778      offset.  */
7779   vid->index = size_binop (MINUS_EXPR, vid->index,
7780                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7781
7782   /* Keep track of this function.  */
7783   VEC_safe_push (tree, gc, vid->fns, orig_fn);
7784
7785   if (vid->generate_vcall_entries)
7786     {
7787       tree base;
7788       tree fn;
7789
7790       /* Find the overriding function.  */
7791       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7792       if (fn == error_mark_node)
7793         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7794                                integer_zero_node);
7795       else
7796         {
7797           base = TREE_VALUE (fn);
7798
7799           /* The vbase we're working on is a primary base of
7800              vid->binfo.  But it might be a lost primary, so its
7801              BINFO_OFFSET might be wrong, so we just use the
7802              BINFO_OFFSET from vid->binfo.  */
7803           vcall_offset = size_diffop (BINFO_OFFSET (base),
7804                                       BINFO_OFFSET (vid->binfo));
7805           vcall_offset = fold_build1 (NOP_EXPR, vtable_entry_type,
7806                                       vcall_offset);
7807         }
7808       /* Add the initializer to the vtable.  */
7809       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7810       vid->last_init = &TREE_CHAIN (*vid->last_init);
7811     }
7812 }
7813
7814 /* Return vtbl initializers for the RTTI entries corresponding to the
7815    BINFO's vtable.  The RTTI entries should indicate the object given
7816    by VID->rtti_binfo.  */
7817
7818 static void
7819 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7820 {
7821   tree b;
7822   tree t;
7823   tree basetype;
7824   tree offset;
7825   tree decl;
7826   tree init;
7827
7828   basetype = BINFO_TYPE (binfo);
7829   t = BINFO_TYPE (vid->rtti_binfo);
7830
7831   /* To find the complete object, we will first convert to our most
7832      primary base, and then add the offset in the vtbl to that value.  */
7833   b = binfo;
7834   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7835          && !BINFO_LOST_PRIMARY_P (b))
7836     {
7837       tree primary_base;
7838
7839       primary_base = get_primary_binfo (b);
7840       gcc_assert (BINFO_PRIMARY_P (primary_base)
7841                   && BINFO_INHERITANCE_CHAIN (primary_base) == b);
7842       b = primary_base;
7843     }
7844   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7845
7846   /* The second entry is the address of the typeinfo object.  */
7847   if (flag_rtti)
7848     decl = build_address (get_tinfo_decl (t));
7849   else
7850     decl = integer_zero_node;
7851
7852   /* Convert the declaration to a type that can be stored in the
7853      vtable.  */
7854   init = build_nop (vfunc_ptr_type_node, decl);
7855   *vid->last_init = build_tree_list (NULL_TREE, init);
7856   vid->last_init = &TREE_CHAIN (*vid->last_init);
7857
7858   /* Add the offset-to-top entry.  It comes earlier in the vtable than
7859      the typeinfo entry.  Convert the offset to look like a
7860      function pointer, so that we can put it in the vtable.  */
7861   init = build_nop (vfunc_ptr_type_node, offset);
7862   *vid->last_init = build_tree_list (NULL_TREE, init);
7863   vid->last_init = &TREE_CHAIN (*vid->last_init);
7864 }
7865
7866 /* Fold a OBJ_TYPE_REF expression to the address of a function.
7867    KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF).  */
7868
7869 tree
7870 cp_fold_obj_type_ref (tree ref, tree known_type)
7871 {
7872   HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
7873   HOST_WIDE_INT i = 0;
7874   tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
7875   tree fndecl;
7876
7877   while (i != index)
7878     {
7879       i += (TARGET_VTABLE_USES_DESCRIPTORS
7880             ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
7881       v = TREE_CHAIN (v);
7882     }
7883
7884   fndecl = BV_FN (v);
7885
7886 #ifdef ENABLE_CHECKING
7887   gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
7888                                   DECL_VINDEX (fndecl)));
7889 #endif
7890
7891   cgraph_node (fndecl)->local.vtable_method = true;
7892
7893   return build_address (fndecl);
7894 }
7895
7896 #include "gt-cp-class.h"