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