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