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