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