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