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