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     {
 299       tree zero = cp_convert (TREE_TYPE (expr), integer_zero_node);
 300       null_test = fold (build2 (NE_EXPR, boolean_type_node,
 301                                 expr, zero));
 302     }
 303
 304   /* If this is a simple base reference, express it as a COMPONENT_REF.  */
 305   if (code == PLUS_EXPR && !virtual_access
 306       /* We don't build base fields for empty bases, and they aren't very
 307          interesting to the optimizers anyway.  */
 308       && !has_empty)
 309     {
 310       expr = build_indirect_ref (expr, NULL);
 311       expr = build_simple_base_path (expr, binfo);
 312       if (want_pointer)
 313         expr = build_address (expr);
 314       target_type = TREE_TYPE (expr);
 315       goto out;
 316     }
 317
 318   if (virtual_access)
 319     {
 320       /* Going via virtual base V_BINFO.  We need the static offset
 321          from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
 322          V_BINFO.  That offset is an entry in D_BINFO's vtable.  */
 323       tree v_offset;
 324
 325       if (fixed_type_p < 0 && in_base_initializer)
 326         {
 327           /* In a base member initializer, we cannot rely on
 328              the vtable being set up. We have to use the vtt_parm.  */
 329           tree derived = BINFO_INHERITANCE_CHAIN (v_binfo);
 330           tree t;
 331
 332           t = TREE_TYPE (TYPE_VFIELD (BINFO_TYPE (derived)));
 333           t = build_pointer_type (t);
 334           v_offset = convert (t, current_vtt_parm);
 335           v_offset = build2 (PLUS_EXPR, t, v_offset,
 336                              BINFO_VPTR_INDEX (derived));
 337           v_offset = build_indirect_ref (v_offset, NULL);
 338         }
 339       else
 340         v_offset = build_vfield_ref (build_indirect_ref (expr, NULL),
 341                                      TREE_TYPE (TREE_TYPE (expr)));
 342
 343       v_offset = build2 (PLUS_EXPR, TREE_TYPE (v_offset),
 344                          v_offset,  BINFO_VPTR_FIELD (v_binfo));
 345       v_offset = build1 (NOP_EXPR,
 346                          build_pointer_type (ptrdiff_type_node),
 347                          v_offset);
 348       v_offset = build_indirect_ref (v_offset, NULL);
 349       TREE_CONSTANT (v_offset) = 1;
 350       TREE_INVARIANT (v_offset) = 1;
 351
 352       offset = convert_to_integer (ptrdiff_type_node,
 353                                    size_diffop (offset,
 354                                                 BINFO_OFFSET (v_binfo)));
 355
 356       if (!integer_zerop (offset))
 357         v_offset = build2 (code, ptrdiff_type_node, v_offset, offset);
 358
 359       if (fixed_type_p < 0)
 360         /* Negative fixed_type_p means this is a constructor or destructor;
 361            virtual base layout is fixed in in-charge [cd]tors, but not in
 362            base [cd]tors.  */
 363         offset = build3 (COND_EXPR, ptrdiff_type_node,
 364                          build2 (EQ_EXPR, boolean_type_node,
 365                                  current_in_charge_parm, integer_zero_node),
 366                          v_offset,
 367                          BINFO_OFFSET (binfo));
 368       else
 369         offset = v_offset;
 370     }
 371
 372   target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo);
 373
 374   target_type = cp_build_qualified_type
 375     (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr))));
 376   ptr_target_type = build_pointer_type (target_type);
 377   if (want_pointer)
 378     target_type = ptr_target_type;
 379
 380   expr = build1 (NOP_EXPR, ptr_target_type, expr);
 381
 382   if (!integer_zerop (offset))
 383     expr = build2 (code, ptr_target_type, expr, offset);
 384   else
 385     null_test = NULL;
 386
 387   if (!want_pointer)
 388     expr = build_indirect_ref (expr, NULL);
 389
 390  out:
 391   if (null_test)
 392     expr = fold (build3 (COND_EXPR, target_type, null_test, expr,
 393                          fold (build1 (NOP_EXPR, target_type,
 394                                        integer_zero_node))));
 395
 396   return expr;
 397 }
 398
 399 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
 400    Perform a derived-to-base conversion by recursively building up a
 401    sequence of COMPONENT_REFs to the appropriate base fields.  */
 402
 403 static tree
 404 build_simple_base_path (tree expr, tree binfo)
 405 {
 406   tree type = BINFO_TYPE (binfo);
 407   tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo);
 408   tree field;
 409
 410   if (d_binfo == NULL_TREE)
 411     {
 412       gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type);
 413       return expr;
 414     }
 415
 416   /* Recurse.  */
 417   expr = build_simple_base_path (expr, d_binfo);
 418
 419   for (field = TYPE_FIELDS (BINFO_TYPE (d_binfo));
 420        field; field = TREE_CHAIN (field))
 421     /* Is this the base field created by build_base_field?  */
 422     if (TREE_CODE (field) == FIELD_DECL
 423         && DECL_FIELD_IS_BASE (field)
 424         && TREE_TYPE (field) == type)
 425       return build_class_member_access_expr (expr, field,
 426                                              NULL_TREE, false);
 427
 428   /* Didn't find the base field?!?  */
 429   gcc_unreachable ();
 430 }
 431
 432 /* Convert OBJECT to the base TYPE.  OBJECT is an expression whose
 433    type is a class type or a pointer to a class type.  In the former
 434    case, TYPE is also a class type; in the latter it is another
 435    pointer type.  If CHECK_ACCESS is true, an error message is emitted
 436    if TYPE is inaccessible.  If OBJECT has pointer type, the value is
 437    assumed to be non-NULL.  */
 438
 439 tree
 440 convert_to_base (tree object, tree type, bool check_access, bool nonnull)
 441 {
 442   tree binfo;
 443   tree object_type;
 444
 445   if (TYPE_PTR_P (TREE_TYPE (object)))
 446     {
 447       object_type = TREE_TYPE (TREE_TYPE (object));
 448       type = TREE_TYPE (type);
 449     }
 450   else
 451     object_type = TREE_TYPE (object);
 452
 453   binfo = lookup_base (object_type, type,
 454                        check_access ? ba_check : ba_unique,
 455                        NULL);
 456   if (!binfo || binfo == error_mark_node)
 457     return error_mark_node;
 458
 459   return build_base_path (PLUS_EXPR, object, binfo, nonnull);
 460 }
 461
 462 /* EXPR is an expression with unqualified class type.  BASE is a base
 463    binfo of that class type.  Returns EXPR, converted to the BASE
 464    type.  This function assumes that EXPR is the most derived class;
 465    therefore virtual bases can be found at their static offsets.  */
 466
 467 tree
 468 convert_to_base_statically (tree expr, tree base)
 469 {
 470   tree expr_type;
 471
 472   expr_type = TREE_TYPE (expr);
 473   if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base), expr_type))
 474     {
 475       tree pointer_type;
 476
 477       pointer_type = build_pointer_type (expr_type);
 478       expr = build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1);
 479       if (!integer_zerop (BINFO_OFFSET (base)))
 480           expr = build2 (PLUS_EXPR, pointer_type, expr,
 481                          build_nop (pointer_type, BINFO_OFFSET (base)));
 482       expr = build_nop (build_pointer_type (BINFO_TYPE (base)), expr);
 483       expr = build1 (INDIRECT_REF, BINFO_TYPE (base), expr);
 484     }
 485
 486   return expr;
 487 }
 488
 489 \f
 490 tree
 491 build_vfield_ref (tree datum, tree type)
 492 {
 493   tree vfield, vcontext;
 494
 495   if (datum == error_mark_node)
 496     return error_mark_node;
 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             {
4560               maybe_register_incomplete_var (field);
4561               /* The visibility of static data members is determined
4562                  at their point of declaration, not their point of
4563                  definition.  */
4564               determine_visibility (field);
4565             }
4566           continue;
4567         }
4568
4569       type = TREE_TYPE (field);
4570
4571       padding = NULL_TREE;
4572
4573       /* If this field is a bit-field whose width is greater than its
4574          type, then there are some special rules for allocating
4575          it.  */
4576       if (DECL_C_BIT_FIELD (field)
4577           && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
4578         {
4579           integer_type_kind itk;
4580           tree integer_type;
4581           bool was_unnamed_p = false;
4582           /* We must allocate the bits as if suitably aligned for the
4583              longest integer type that fits in this many bits.  type
4584              of the field.  Then, we are supposed to use the left over
4585              bits as additional padding.  */
4586           for (itk = itk_char; itk != itk_none; ++itk)
4587             if (INT_CST_LT (DECL_SIZE (field),
4588                             TYPE_SIZE (integer_types[itk])))
4589               break;
4590
4591           /* ITK now indicates a type that is too large for the
4592              field.  We have to back up by one to find the largest
4593              type that fits.  */
4594           integer_type = integer_types[itk - 1];
4595
4596           /* Figure out how much additional padding is required.  GCC
4597              3.2 always created a padding field, even if it had zero
4598              width.  */
4599           if (!abi_version_at_least (2)
4600               || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
4601             {
4602               if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
4603                 /* In a union, the padding field must have the full width
4604                    of the bit-field; all fields start at offset zero.  */
4605                 padding = DECL_SIZE (field);
4606               else
4607                 {
4608                   if (warn_abi && TREE_CODE (t) == UNION_TYPE)
4609                     warning ("size assigned to %qT may not be "
4610                              "ABI-compliant and may change in a future "
4611                              "version of GCC",
4612                              t);
4613                   padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
4614                                         TYPE_SIZE (integer_type));
4615                 }
4616             }
4617 #ifdef PCC_BITFIELD_TYPE_MATTERS
4618           /* An unnamed bitfield does not normally affect the
4619              alignment of the containing class on a target where
4620              PCC_BITFIELD_TYPE_MATTERS.  But, the C++ ABI does not
4621              make any exceptions for unnamed bitfields when the
4622              bitfields are longer than their types.  Therefore, we
4623              temporarily give the field a name.  */
4624           if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
4625             {
4626               was_unnamed_p = true;
4627               DECL_NAME (field) = make_anon_name ();
4628             }
4629 #endif
4630           DECL_SIZE (field) = TYPE_SIZE (integer_type);
4631           DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
4632           DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
4633           layout_nonempty_base_or_field (rli, field, NULL_TREE,
4634                                          empty_base_offsets);
4635           if (was_unnamed_p)
4636             DECL_NAME (field) = NULL_TREE;
4637           /* Now that layout has been performed, set the size of the
4638              field to the size of its declared type; the rest of the
4639              field is effectively invisible.  */
4640           DECL_SIZE (field) = TYPE_SIZE (type);
4641           /* We must also reset the DECL_MODE of the field.  */
4642           if (abi_version_at_least (2))
4643             DECL_MODE (field) = TYPE_MODE (type);
4644           else if (warn_abi
4645                    && DECL_MODE (field) != TYPE_MODE (type))
4646             /* Versions of G++ before G++ 3.4 did not reset the
4647                DECL_MODE.  */
4648             warning ("the offset of %qD may not be ABI-compliant and may "
4649                      "change in a future version of GCC", field);
4650         }
4651       else
4652         layout_nonempty_base_or_field (rli, field, NULL_TREE,
4653                                        empty_base_offsets);
4654
4655       /* Remember the location of any empty classes in FIELD.  */
4656       if (abi_version_at_least (2))
4657         record_subobject_offsets (TREE_TYPE (field),
4658                                   byte_position(field),
4659                                   empty_base_offsets,
4660                                   /*vbases_p=*/1);
4661
4662       /* If a bit-field does not immediately follow another bit-field,
4663          and yet it starts in the middle of a byte, we have failed to
4664          comply with the ABI.  */
4665       if (warn_abi
4666           && DECL_C_BIT_FIELD (field)
4667           && !last_field_was_bitfield
4668           && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
4669                                          DECL_FIELD_BIT_OFFSET (field),
4670                                          bitsize_unit_node)))
4671         cp_warning_at ("offset of %qD is not ABI-compliant and may "
4672                        "change in a future version of GCC",
4673                        field);
4674
4675       /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4676          offset of the field.  */
4677       if (warn_abi
4678           && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
4679                                   byte_position (field))
4680           && contains_empty_class_p (TREE_TYPE (field)))
4681         cp_warning_at ("%qD contains empty classes which may cause base "
4682                        "classes to be placed at different locations in a "
4683                        "future version of GCC",
4684                        field);
4685
4686       /* If we needed additional padding after this field, add it
4687          now.  */
4688       if (padding)
4689         {
4690           tree padding_field;
4691
4692           padding_field = build_decl (FIELD_DECL,
4693                                       NULL_TREE,
4694                                       char_type_node);
4695           DECL_BIT_FIELD (padding_field) = 1;
4696           DECL_SIZE (padding_field) = padding;
4697           DECL_CONTEXT (padding_field) = t;
4698           DECL_ARTIFICIAL (padding_field) = 1;
4699           layout_nonempty_base_or_field (rli, padding_field,
4700                                          NULL_TREE,
4701                                          empty_base_offsets);
4702         }
4703
4704       last_field_was_bitfield = DECL_C_BIT_FIELD (field);
4705     }
4706
4707   if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
4708     {
4709       /* Make sure that we are on a byte boundary so that the size of
4710          the class without virtual bases will always be a round number
4711          of bytes.  */
4712       rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT);
4713       normalize_rli (rli);
4714     }
4715
4716   /* G++ 3.2 does not allow virtual bases to be overlaid with tail
4717      padding.  */
4718   if (!abi_version_at_least (2))
4719     include_empty_classes(rli);
4720
4721   /* Delete all zero-width bit-fields from the list of fields.  Now
4722      that the type is laid out they are no longer important.  */
4723   remove_zero_width_bit_fields (t);
4724
4725   /* Create the version of T used for virtual bases.  We do not use
4726      make_aggr_type for this version; this is an artificial type.  For
4727      a POD type, we just reuse T.  */
4728   if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t))
4729     {
4730       base_t = make_node (TREE_CODE (t));
4731
4732       /* Set the size and alignment for the new type.  In G++ 3.2, all
4733          empty classes were considered to have size zero when used as
4734          base classes.  */
4735       if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
4736         {
4737           TYPE_SIZE (base_t) = bitsize_zero_node;
4738           TYPE_SIZE_UNIT (base_t) = size_zero_node;
4739           if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
4740             warning ("layout of classes derived from empty class %qT "
4741                      "may change in a future version of GCC",
4742                      t);
4743         }
4744       else
4745         {
4746           tree eoc;
4747
4748           /* If the ABI version is not at least two, and the last
4749              field was a bit-field, RLI may not be on a byte
4750              boundary.  In particular, rli_size_unit_so_far might
4751              indicate the last complete byte, while rli_size_so_far
4752              indicates the total number of bits used.  Therefore,
4753              rli_size_so_far, rather than rli_size_unit_so_far, is
4754              used to compute TYPE_SIZE_UNIT.  */
4755           eoc = end_of_class (t, /*include_virtuals_p=*/0);
4756           TYPE_SIZE_UNIT (base_t)
4757             = size_binop (MAX_EXPR,
4758                           convert (sizetype,
4759                                    size_binop (CEIL_DIV_EXPR,
4760                                                rli_size_so_far (rli),
4761                                                bitsize_int (BITS_PER_UNIT))),
4762                           eoc);
4763           TYPE_SIZE (base_t)
4764             = size_binop (MAX_EXPR,
4765                           rli_size_so_far (rli),
4766                           size_binop (MULT_EXPR,
4767                                       convert (bitsizetype, eoc),
4768                                       bitsize_int (BITS_PER_UNIT)));
4769         }
4770       TYPE_ALIGN (base_t) = rli->record_align;
4771       TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
4772
4773       /* Copy the fields from T.  */
4774       next_field = &TYPE_FIELDS (base_t);
4775       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4776         if (TREE_CODE (field) == FIELD_DECL)
4777           {
4778             *next_field = build_decl (FIELD_DECL,
4779                                       DECL_NAME (field),
4780                                       TREE_TYPE (field));
4781             DECL_CONTEXT (*next_field) = base_t;
4782             DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
4783             DECL_FIELD_BIT_OFFSET (*next_field)
4784               = DECL_FIELD_BIT_OFFSET (field);
4785             DECL_SIZE (*next_field) = DECL_SIZE (field);
4786             DECL_MODE (*next_field) = DECL_MODE (field);
4787             next_field = &TREE_CHAIN (*next_field);
4788           }
4789
4790       /* Record the base version of the type.  */
4791       CLASSTYPE_AS_BASE (t) = base_t;
4792       TYPE_CONTEXT (base_t) = t;
4793     }
4794   else
4795     CLASSTYPE_AS_BASE (t) = t;
4796
4797   /* Every empty class contains an empty class.  */
4798   if (CLASSTYPE_EMPTY_P (t))
4799     CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
4800
4801   /* Set the TYPE_DECL for this type to contain the right
4802      value for DECL_OFFSET, so that we can use it as part
4803      of a COMPONENT_REF for multiple inheritance.  */
4804   layout_decl (TYPE_MAIN_DECL (t), 0);
4805
4806   /* Now fix up any virtual base class types that we left lying
4807      around.  We must get these done before we try to lay out the
4808      virtual function table.  As a side-effect, this will remove the
4809      base subobject fields.  */
4810   layout_virtual_bases (rli, empty_base_offsets);
4811
4812   /* Make sure that empty classes are reflected in RLI at this
4813      point.  */
4814   include_empty_classes(rli);
4815
4816   /* Make sure not to create any structures with zero size.  */
4817   if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
4818     place_field (rli,
4819                  build_decl (FIELD_DECL, NULL_TREE, char_type_node));
4820
4821   /* Let the back-end lay out the type.  */
4822   finish_record_layout (rli, /*free_p=*/true);
4823
4824   /* Warn about bases that can't be talked about due to ambiguity.  */
4825   warn_about_ambiguous_bases (t);
4826
4827   /* Now that we're done with layout, give the base fields the real types.  */
4828   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4829     if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
4830       TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
4831
4832   /* Clean up.  */
4833   splay_tree_delete (empty_base_offsets);
4834 }
4835
4836 /* Determine the "key method" for the class type indicated by TYPE,
4837    and set CLASSTYPE_KEY_METHOD accordingly.  */
4838
4839 void
4840 determine_key_method (tree type)
4841 {
4842   tree method;
4843
4844   if (TYPE_FOR_JAVA (type)
4845       || processing_template_decl
4846       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
4847       || CLASSTYPE_INTERFACE_KNOWN (type))
4848     return;
4849
4850   /* The key method is the first non-pure virtual function that is not
4851      inline at the point of class definition.  On some targets the
4852      key function may not be inline; those targets should not call
4853      this function until the end of the translation unit.  */
4854   for (method = TYPE_METHODS (type); method != NULL_TREE;
4855        method = TREE_CHAIN (method))
4856     if (DECL_VINDEX (method) != NULL_TREE
4857         && ! DECL_DECLARED_INLINE_P (method)
4858         && ! DECL_PURE_VIRTUAL_P (method))
4859       {
4860         CLASSTYPE_KEY_METHOD (type) = method;
4861         break;
4862       }
4863
4864   return;
4865 }
4866
4867 /* Perform processing required when the definition of T (a class type)
4868    is complete.  */
4869
4870 void
4871 finish_struct_1 (tree t)
4872 {
4873   tree x;
4874   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
4875   tree virtuals = NULL_TREE;
4876   int n_fields = 0;
4877
4878   if (COMPLETE_TYPE_P (t))
4879     {
4880       gcc_assert (IS_AGGR_TYPE (t));
4881       error ("redefinition of %q#T", t);
4882       popclass ();
4883       return;
4884     }
4885
4886   /* If this type was previously laid out as a forward reference,
4887      make sure we lay it out again.  */
4888   TYPE_SIZE (t) = NULL_TREE;
4889   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
4890
4891   fixup_inline_methods (t);
4892
4893   /* Make assumptions about the class; we'll reset the flags if
4894      necessary.  */
4895   CLASSTYPE_EMPTY_P (t) = 1;
4896   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
4897   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
4898
4899   /* Do end-of-class semantic processing: checking the validity of the
4900      bases and members and add implicitly generated methods.  */
4901   check_bases_and_members (t);
4902
4903   /* Find the key method.  */
4904   if (TYPE_CONTAINS_VPTR_P (t))
4905     {
4906       /* The Itanium C++ ABI permits the key method to be chosen when
4907          the class is defined -- even though the key method so
4908          selected may later turn out to be an inline function.  On
4909          some systems (such as ARM Symbian OS) the key method cannot
4910          be determined until the end of the translation unit.  On such
4911          systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
4912          will cause the class to be added to KEYED_CLASSES.  Then, in
4913          finish_file we will determine the key method.  */
4914       if (targetm.cxx.key_method_may_be_inline ())
4915         determine_key_method (t);
4916
4917       /* If a polymorphic class has no key method, we may emit the vtable
4918          in every translation unit where the class definition appears.  */
4919       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
4920         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
4921     }
4922
4923   /* Layout the class itself.  */
4924   layout_class_type (t, &virtuals);
4925   if (CLASSTYPE_AS_BASE (t) != t)
4926     /* We use the base type for trivial assignments, and hence it
4927        needs a mode.  */
4928     compute_record_mode (CLASSTYPE_AS_BASE (t));
4929
4930   virtuals = modify_all_vtables (t, nreverse (virtuals));
4931
4932   /* If necessary, create the primary vtable for this class.  */
4933   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
4934     {
4935       /* We must enter these virtuals into the table.  */
4936       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
4937         build_primary_vtable (NULL_TREE, t);
4938       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
4939         /* Here we know enough to change the type of our virtual
4940            function table, but we will wait until later this function.  */
4941         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
4942     }
4943
4944   if (TYPE_CONTAINS_VPTR_P (t))
4945     {
4946       int vindex;
4947       tree fn;
4948
4949       if (BINFO_VTABLE (TYPE_BINFO (t)))
4950         gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
4951       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
4952         gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
4953
4954       /* Add entries for virtual functions introduced by this class.  */
4955       BINFO_VIRTUALS (TYPE_BINFO (t))
4956         = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
4957
4958       /* Set DECL_VINDEX for all functions declared in this class.  */
4959       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
4960            fn;
4961            fn = TREE_CHAIN (fn),
4962              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
4963                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
4964         {
4965           tree fndecl = BV_FN (fn);
4966
4967           if (DECL_THUNK_P (fndecl))
4968             /* A thunk. We should never be calling this entry directly
4969                from this vtable -- we'd use the entry for the non
4970                thunk base function.  */
4971             DECL_VINDEX (fndecl) = NULL_TREE;
4972           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
4973             DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
4974         }
4975     }
4976
4977   finish_struct_bits (t);
4978
4979   /* Complete the rtl for any static member objects of the type we're
4980      working on.  */
4981   for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
4982     if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
4983         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
4984       DECL_MODE (x) = TYPE_MODE (t);
4985
4986   /* Done with FIELDS...now decide whether to sort these for
4987      faster lookups later.
4988
4989      We use a small number because most searches fail (succeeding
4990      ultimately as the search bores through the inheritance
4991      hierarchy), and we want this failure to occur quickly.  */
4992
4993   n_fields = count_fields (TYPE_FIELDS (t));
4994   if (n_fields > 7)
4995     {
4996       struct sorted_fields_type *field_vec = GGC_NEWVAR
4997          (struct sorted_fields_type,
4998           sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
4999       field_vec->len = n_fields;
5000       add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5001       qsort (field_vec->elts, n_fields, sizeof (tree),
5002              field_decl_cmp);
5003       if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5004         retrofit_lang_decl (TYPE_MAIN_DECL (t));
5005       DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5006     }
5007
5008   /* Make the rtl for any new vtables we have created, and unmark
5009      the base types we marked.  */
5010   finish_vtbls (t);
5011
5012   /* Build the VTT for T.  */
5013   build_vtt (t);
5014
5015   if (warn_nonvdtor && TYPE_POLYMORPHIC_P (t) && TYPE_HAS_DESTRUCTOR (t)
5016       && !DECL_VINDEX (CLASSTYPE_DESTRUCTORS (t)))
5017
5018     {
5019       tree dtor = CLASSTYPE_DESTRUCTORS (t);
5020
5021       /* Warn only if the dtor is non-private or the class has friends */
5022       if (!TREE_PRIVATE (dtor) ||
5023           (CLASSTYPE_FRIEND_CLASSES (t) ||
5024            DECL_FRIENDLIST (TYPE_MAIN_DECL (t))))
5025         warning ("%q#T has virtual functions but non-virtual destructor", t);
5026     }
5027
5028   complete_vars (t);
5029
5030   if (warn_overloaded_virtual)
5031     warn_hidden (t);
5032
5033   maybe_suppress_debug_info (t);
5034
5035   dump_class_hierarchy (t);
5036
5037   /* Finish debugging output for this type.  */
5038   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5039 }
5040
5041 /* When T was built up, the member declarations were added in reverse
5042    order.  Rearrange them to declaration order.  */
5043
5044 void
5045 unreverse_member_declarations (tree t)
5046 {
5047   tree next;
5048   tree prev;
5049   tree x;
5050
5051   /* The following lists are all in reverse order.  Put them in
5052      declaration order now.  */
5053   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5054   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5055
5056   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5057      reverse order, so we can't just use nreverse.  */
5058   prev = NULL_TREE;
5059   for (x = TYPE_FIELDS (t);
5060        x && TREE_CODE (x) != TYPE_DECL;
5061        x = next)
5062     {
5063       next = TREE_CHAIN (x);
5064       TREE_CHAIN (x) = prev;
5065       prev = x;
5066     }
5067   if (prev)
5068     {
5069       TREE_CHAIN (TYPE_FIELDS (t)) = x;
5070       if (prev)
5071         TYPE_FIELDS (t) = prev;
5072     }
5073 }
5074
5075 tree
5076 finish_struct (tree t, tree attributes)
5077 {
5078   location_t saved_loc = input_location;
5079
5080   /* Now that we've got all the field declarations, reverse everything
5081      as necessary.  */
5082   unreverse_member_declarations (t);
5083
5084   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5085
5086   /* Nadger the current location so that diagnostics point to the start of
5087      the struct, not the end.  */
5088   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5089
5090   if (processing_template_decl)
5091     {
5092       tree x;
5093
5094       finish_struct_methods (t);
5095       TYPE_SIZE (t) = bitsize_zero_node;
5096
5097       /* We need to emit an error message if this type was used as a parameter
5098          and it is an abstract type, even if it is a template. We construct
5099          a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5100          account and we call complete_vars with this type, which will check
5101          the PARM_DECLS. Note that while the type is being defined,
5102          CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5103          (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it.  */
5104       CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5105       for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
5106         if (DECL_PURE_VIRTUAL_P (x))
5107           VEC_safe_push (tree, CLASSTYPE_PURE_VIRTUALS (t), x);
5108       complete_vars (t);
5109     }
5110   else
5111     finish_struct_1 (t);
5112
5113   input_location = saved_loc;
5114
5115   TYPE_BEING_DEFINED (t) = 0;
5116
5117   if (current_class_type)
5118     popclass ();
5119   else
5120     error ("trying to finish struct, but kicked out due to previous parse errors");
5121
5122   if (processing_template_decl && at_function_scope_p ())
5123     add_stmt (build_min (TAG_DEFN, t));
5124
5125   return t;
5126 }
5127 \f
5128 /* Return the dynamic type of INSTANCE, if known.
5129    Used to determine whether the virtual function table is needed
5130    or not.
5131
5132    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5133    of our knowledge of its type.  *NONNULL should be initialized
5134    before this function is called.  */
5135
5136 static tree
5137 fixed_type_or_null (tree instance, int* nonnull, int* cdtorp)
5138 {
5139   switch (TREE_CODE (instance))
5140     {
5141     case INDIRECT_REF:
5142       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5143         return NULL_TREE;
5144       else
5145         return fixed_type_or_null (TREE_OPERAND (instance, 0),
5146                                    nonnull, cdtorp);
5147
5148     case CALL_EXPR:
5149       /* This is a call to a constructor, hence it's never zero.  */
5150       if (TREE_HAS_CONSTRUCTOR (instance))
5151         {
5152           if (nonnull)
5153             *nonnull = 1;
5154           return TREE_TYPE (instance);
5155         }
5156       return NULL_TREE;
5157
5158     case SAVE_EXPR:
5159       /* This is a call to a constructor, hence it's never zero.  */
5160       if (TREE_HAS_CONSTRUCTOR (instance))
5161         {
5162           if (nonnull)
5163             *nonnull = 1;
5164           return TREE_TYPE (instance);
5165         }
5166       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5167
5168     case PLUS_EXPR:
5169     case MINUS_EXPR:
5170       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5171         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5172       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5173         /* Propagate nonnull.  */
5174         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5175       return NULL_TREE;
5176
5177     case NOP_EXPR:
5178     case CONVERT_EXPR:
5179       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5180
5181     case ADDR_EXPR:
5182       instance = TREE_OPERAND (instance, 0);
5183       if (nonnull)
5184         {
5185           /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5186              with a real object -- given &p->f, p can still be null.  */
5187           tree t = get_base_address (instance);
5188           /* ??? Probably should check DECL_WEAK here.  */
5189           if (t && DECL_P (t))
5190             *nonnull = 1;
5191         }
5192       return fixed_type_or_null (instance, nonnull, cdtorp);
5193
5194     case COMPONENT_REF:
5195       /* If this component is really a base class reference, then the field
5196          itself isn't definitive.  */
5197       if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5198         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5199       return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull, cdtorp);
5200
5201     case VAR_DECL:
5202     case FIELD_DECL:
5203       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5204           && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
5205         {
5206           if (nonnull)
5207             *nonnull = 1;
5208           return TREE_TYPE (TREE_TYPE (instance));
5209         }
5210       /* fall through...  */
5211     case TARGET_EXPR:
5212     case PARM_DECL:
5213     case RESULT_DECL:
5214       if (IS_AGGR_TYPE (TREE_TYPE (instance)))
5215         {
5216           if (nonnull)
5217             *nonnull = 1;
5218           return TREE_TYPE (instance);
5219         }
5220       else if (instance == current_class_ptr)
5221         {
5222           if (nonnull)
5223             *nonnull = 1;
5224
5225           /* if we're in a ctor or dtor, we know our type.  */
5226           if (DECL_LANG_SPECIFIC (current_function_decl)
5227               && (DECL_CONSTRUCTOR_P (current_function_decl)
5228                   || DECL_DESTRUCTOR_P (current_function_decl)))
5229             {
5230               if (cdtorp)
5231                 *cdtorp = 1;
5232               return TREE_TYPE (TREE_TYPE (instance));
5233             }
5234         }
5235       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5236         {
5237           /* Reference variables should be references to objects.  */
5238           if (nonnull)
5239             *nonnull = 1;
5240
5241           /* DECL_VAR_MARKED_P is used to prevent recursion; a
5242              variable's initializer may refer to the variable
5243              itself.  */
5244           if (TREE_CODE (instance) == VAR_DECL
5245               && DECL_INITIAL (instance)
5246               && !DECL_VAR_MARKED_P (instance))
5247             {
5248               tree type;
5249               DECL_VAR_MARKED_P (instance) = 1;
5250               type = fixed_type_or_null (DECL_INITIAL (instance),
5251                                          nonnull, cdtorp);
5252               DECL_VAR_MARKED_P (instance) = 0;
5253               return type;
5254             }
5255         }
5256       return NULL_TREE;
5257
5258     default:
5259       return NULL_TREE;
5260     }
5261 }
5262
5263 /* Return nonzero if the dynamic type of INSTANCE is known, and
5264    equivalent to the static type.  We also handle the case where
5265    INSTANCE is really a pointer. Return negative if this is a
5266    ctor/dtor. There the dynamic type is known, but this might not be
5267    the most derived base of the original object, and hence virtual
5268    bases may not be layed out according to this type.
5269
5270    Used to determine whether the virtual function table is needed
5271    or not.
5272
5273    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5274    of our knowledge of its type.  *NONNULL should be initialized
5275    before this function is called.  */
5276
5277 int
5278 resolves_to_fixed_type_p (tree instance, int* nonnull)
5279 {
5280   tree t = TREE_TYPE (instance);
5281   int cdtorp = 0;
5282
5283   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5284   if (fixed == NULL_TREE)
5285     return 0;
5286   if (POINTER_TYPE_P (t))
5287     t = TREE_TYPE (t);
5288   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5289     return 0;
5290   return cdtorp ? -1 : 1;
5291 }
5292
5293 \f
5294 void
5295 init_class_processing (void)
5296 {
5297   current_class_depth = 0;
5298   current_class_stack_size = 10;
5299   current_class_stack
5300     = xmalloc (current_class_stack_size * sizeof (struct class_stack_node));
5301   VARRAY_TREE_INIT (local_classes, 8, "local_classes");
5302
5303   ridpointers[(int) RID_PUBLIC] = access_public_node;
5304   ridpointers[(int) RID_PRIVATE] = access_private_node;
5305   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5306 }
5307
5308 /* Restore the cached PREVIOUS_CLASS_LEVEL.  */
5309
5310 static void
5311 restore_class_cache (void)
5312 {
5313   tree type;
5314
5315   /* We are re-entering the same class we just left, so we don't
5316      have to search the whole inheritance matrix to find all the
5317      decls to bind again.  Instead, we install the cached
5318      class_shadowed list and walk through it binding names.  */
5319   push_binding_level (previous_class_level);
5320   class_binding_level = previous_class_level;
5321   /* Restore IDENTIFIER_TYPE_VALUE.  */
5322   for (type = class_binding_level->type_shadowed;
5323        type;
5324        type = TREE_CHAIN (type))
5325     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5326 }
5327
5328 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5329    appropriate for TYPE.
5330
5331    So that we may avoid calls to lookup_name, we cache the _TYPE
5332    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5333
5334    For multiple inheritance, we perform a two-pass depth-first search
5335    of the type lattice.  */
5336
5337 void
5338 pushclass (tree type)
5339 {
5340   type = TYPE_MAIN_VARIANT (type);
5341
5342   /* Make sure there is enough room for the new entry on the stack.  */
5343   if (current_class_depth + 1 >= current_class_stack_size)
5344     {
5345       current_class_stack_size *= 2;
5346       current_class_stack
5347         = xrealloc (current_class_stack,
5348                     current_class_stack_size
5349                     * sizeof (struct class_stack_node));
5350     }
5351
5352   /* Insert a new entry on the class stack.  */
5353   current_class_stack[current_class_depth].name = current_class_name;
5354   current_class_stack[current_class_depth].type = current_class_type;
5355   current_class_stack[current_class_depth].access = current_access_specifier;
5356   current_class_stack[current_class_depth].names_used = 0;
5357   current_class_depth++;
5358
5359   /* Now set up the new type.  */
5360   current_class_name = TYPE_NAME (type);
5361   if (TREE_CODE (current_class_name) == TYPE_DECL)
5362     current_class_name = DECL_NAME (current_class_name);
5363   current_class_type = type;
5364
5365   /* By default, things in classes are private, while things in
5366      structures or unions are public.  */
5367   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5368                               ? access_private_node
5369                               : access_public_node);
5370
5371   if (previous_class_level
5372       && type != previous_class_level->this_entity
5373       && current_class_depth == 1)
5374     {
5375       /* Forcibly remove any old class remnants.  */
5376       invalidate_class_lookup_cache ();
5377     }
5378
5379   if (!previous_class_level
5380       || type != previous_class_level->this_entity
5381       || current_class_depth > 1)
5382     pushlevel_class ();
5383   else
5384     restore_class_cache ();
5385 }
5386
5387 /* When we exit a toplevel class scope, we save its binding level so
5388    that we can restore it quickly.  Here, we've entered some other
5389    class, so we must invalidate our cache.  */
5390
5391 void
5392 invalidate_class_lookup_cache (void)
5393 {
5394   previous_class_level = NULL;
5395 }
5396
5397 /* Get out of the current class scope. If we were in a class scope
5398    previously, that is the one popped to.  */
5399
5400 void
5401 popclass (void)
5402 {
5403   poplevel_class ();
5404
5405   current_class_depth--;
5406   current_class_name = current_class_stack[current_class_depth].name;
5407   current_class_type = current_class_stack[current_class_depth].type;
5408   current_access_specifier = current_class_stack[current_class_depth].access;
5409   if (current_class_stack[current_class_depth].names_used)
5410     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5411 }
5412
5413 /* Returns 1 if current_class_type is either T or a nested type of T.
5414    We start looking from 1 because entry 0 is from global scope, and has
5415    no type.  */
5416
5417 int
5418 currently_open_class (tree t)
5419 {
5420   int i;
5421   if (current_class_type && same_type_p (t, current_class_type))
5422     return 1;
5423   for (i = 1; i < current_class_depth; ++i)
5424     if (current_class_stack[i].type
5425         && same_type_p (current_class_stack [i].type, t))
5426       return 1;
5427   return 0;
5428 }
5429
5430 /* If either current_class_type or one of its enclosing classes are derived
5431    from T, return the appropriate type.  Used to determine how we found
5432    something via unqualified lookup.  */
5433
5434 tree
5435 currently_open_derived_class (tree t)
5436 {
5437   int i;
5438
5439   /* The bases of a dependent type are unknown.  */
5440   if (dependent_type_p (t))
5441     return NULL_TREE;
5442
5443   if (!current_class_type)
5444     return NULL_TREE;
5445
5446   if (DERIVED_FROM_P (t, current_class_type))
5447     return current_class_type;
5448
5449   for (i = current_class_depth - 1; i > 0; --i)
5450     if (DERIVED_FROM_P (t, current_class_stack[i].type))
5451       return current_class_stack[i].type;
5452
5453   return NULL_TREE;
5454 }
5455
5456 /* When entering a class scope, all enclosing class scopes' names with
5457    static meaning (static variables, static functions, types and
5458    enumerators) have to be visible.  This recursive function calls
5459    pushclass for all enclosing class contexts until global or a local
5460    scope is reached.  TYPE is the enclosed class.  */
5461
5462 void
5463 push_nested_class (tree type)
5464 {
5465   tree context;
5466
5467   /* A namespace might be passed in error cases, like A::B:C.  */
5468   if (type == NULL_TREE
5469       || type == error_mark_node
5470       || TREE_CODE (type) == NAMESPACE_DECL
5471       || ! IS_AGGR_TYPE (type)
5472       || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5473       || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
5474     return;
5475
5476   context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
5477
5478   if (context && CLASS_TYPE_P (context))
5479     push_nested_class (context);
5480   pushclass (type);
5481 }
5482
5483 /* Undoes a push_nested_class call.  */
5484
5485 void
5486 pop_nested_class (void)
5487 {
5488   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5489
5490   popclass ();
5491   if (context && CLASS_TYPE_P (context))
5492     pop_nested_class ();
5493 }
5494
5495 /* Returns the number of extern "LANG" blocks we are nested within.  */
5496
5497 int
5498 current_lang_depth (void)
5499 {
5500   return VARRAY_ACTIVE_SIZE (current_lang_base);
5501 }
5502
5503 /* Set global variables CURRENT_LANG_NAME to appropriate value
5504    so that behavior of name-mangling machinery is correct.  */
5505
5506 void
5507 push_lang_context (tree name)
5508 {
5509   VARRAY_PUSH_TREE (current_lang_base, current_lang_name);
5510
5511   if (name == lang_name_cplusplus)
5512     {
5513       current_lang_name = name;
5514     }
5515   else if (name == lang_name_java)
5516     {
5517       current_lang_name = name;
5518       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5519          (See record_builtin_java_type in decl.c.)  However, that causes
5520          incorrect debug entries if these types are actually used.
5521          So we re-enable debug output after extern "Java".  */
5522       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5523       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5524       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5525       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5526       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5527       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5528       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5529       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5530     }
5531   else if (name == lang_name_c)
5532     {
5533       current_lang_name = name;
5534     }
5535   else
5536     error ("language string %<\"%E\"%> not recognized", name);
5537 }
5538
5539 /* Get out of the current language scope.  */
5540
5541 void
5542 pop_lang_context (void)
5543 {
5544   current_lang_name = VARRAY_TOP_TREE (current_lang_base);
5545   VARRAY_POP (current_lang_base);
5546 }
5547 \f
5548 /* Type instantiation routines.  */
5549
5550 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5551    matches the TARGET_TYPE.  If there is no satisfactory match, return
5552    error_mark_node, and issue a error & warning messages under control
5553    of FLAGS.  Permit pointers to member function if FLAGS permits.  If
5554    TEMPLATE_ONLY, the name of the overloaded function was a
5555    template-id, and EXPLICIT_TARGS are the explicitly provided
5556    template arguments.  */
5557
5558 static tree
5559 resolve_address_of_overloaded_function (tree target_type,
5560                                         tree overload,
5561                                         tsubst_flags_t flags,
5562                                         bool template_only,
5563                                         tree explicit_targs)
5564 {
5565   /* Here's what the standard says:
5566
5567        [over.over]
5568
5569        If the name is a function template, template argument deduction
5570        is done, and if the argument deduction succeeds, the deduced
5571        arguments are used to generate a single template function, which
5572        is added to the set of overloaded functions considered.
5573
5574        Non-member functions and static member functions match targets of
5575        type "pointer-to-function" or "reference-to-function."  Nonstatic
5576        member functions match targets of type "pointer-to-member
5577        function;" the function type of the pointer to member is used to
5578        select the member function from the set of overloaded member
5579        functions.  If a nonstatic member function is selected, the
5580        reference to the overloaded function name is required to have the
5581        form of a pointer to member as described in 5.3.1.
5582
5583        If more than one function is selected, any template functions in
5584        the set are eliminated if the set also contains a non-template
5585        function, and any given template function is eliminated if the
5586        set contains a second template function that is more specialized
5587        than the first according to the partial ordering rules 14.5.5.2.
5588        After such eliminations, if any, there shall remain exactly one
5589        selected function.  */
5590
5591   int is_ptrmem = 0;
5592   int is_reference = 0;
5593   /* We store the matches in a TREE_LIST rooted here.  The functions
5594      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5595      interoperability with most_specialized_instantiation.  */
5596   tree matches = NULL_TREE;
5597   tree fn;
5598
5599   /* By the time we get here, we should be seeing only real
5600      pointer-to-member types, not the internal POINTER_TYPE to
5601      METHOD_TYPE representation.  */
5602   gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
5603               || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
5604
5605   gcc_assert (is_overloaded_fn (overload));
5606
5607   /* Check that the TARGET_TYPE is reasonable.  */
5608   if (TYPE_PTRFN_P (target_type))
5609     /* This is OK.  */;
5610   else if (TYPE_PTRMEMFUNC_P (target_type))
5611     /* This is OK, too.  */
5612     is_ptrmem = 1;
5613   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5614     {
5615       /* This is OK, too.  This comes from a conversion to reference
5616          type.  */
5617       target_type = build_reference_type (target_type);
5618       is_reference = 1;
5619     }
5620   else
5621     {
5622       if (flags & tf_error)
5623         error ("cannot resolve overloaded function %qD based on"
5624                " conversion to type %qT",
5625                DECL_NAME (OVL_FUNCTION (overload)), target_type);
5626       return error_mark_node;
5627     }
5628
5629   /* If we can find a non-template function that matches, we can just
5630      use it.  There's no point in generating template instantiations
5631      if we're just going to throw them out anyhow.  But, of course, we
5632      can only do this when we don't *need* a template function.  */
5633   if (!template_only)
5634     {
5635       tree fns;
5636
5637       for (fns = overload; fns; fns = OVL_NEXT (fns))
5638         {
5639           tree fn = OVL_CURRENT (fns);
5640           tree fntype;
5641
5642           if (TREE_CODE (fn) == TEMPLATE_DECL)
5643             /* We're not looking for templates just yet.  */
5644             continue;
5645
5646           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5647               != is_ptrmem)
5648             /* We're looking for a non-static member, and this isn't
5649                one, or vice versa.  */
5650             continue;
5651
5652           /* Ignore anticipated decls of undeclared builtins.  */
5653           if (DECL_ANTICIPATED (fn))
5654             continue;
5655
5656           /* See if there's a match.  */
5657           fntype = TREE_TYPE (fn);
5658           if (is_ptrmem)
5659             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5660           else if (!is_reference)
5661             fntype = build_pointer_type (fntype);
5662
5663           if (can_convert_arg (target_type, fntype, fn))
5664             matches = tree_cons (fn, NULL_TREE, matches);
5665         }
5666     }
5667
5668   /* Now, if we've already got a match (or matches), there's no need
5669      to proceed to the template functions.  But, if we don't have a
5670      match we need to look at them, too.  */
5671   if (!matches)
5672     {
5673       tree target_fn_type;
5674       tree target_arg_types;
5675       tree target_ret_type;
5676       tree fns;
5677
5678       if (is_ptrmem)
5679         target_fn_type
5680           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5681       else
5682         target_fn_type = TREE_TYPE (target_type);
5683       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5684       target_ret_type = TREE_TYPE (target_fn_type);
5685
5686       /* Never do unification on the 'this' parameter.  */
5687       if (TREE_CODE (target_fn_type) == METHOD_TYPE)
5688         target_arg_types = TREE_CHAIN (target_arg_types);
5689
5690       for (fns = overload; fns; fns = OVL_NEXT (fns))
5691         {
5692           tree fn = OVL_CURRENT (fns);
5693           tree instantiation;
5694           tree instantiation_type;
5695           tree targs;
5696
5697           if (TREE_CODE (fn) != TEMPLATE_DECL)
5698             /* We're only looking for templates.  */
5699             continue;
5700
5701           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5702               != is_ptrmem)
5703             /* We're not looking for a non-static member, and this is
5704                one, or vice versa.  */
5705             continue;
5706
5707           /* Try to do argument deduction.  */
5708           targs = make_tree_vec (DECL_NTPARMS (fn));
5709           if (fn_type_unification (fn, explicit_targs, targs,
5710                                    target_arg_types, target_ret_type,
5711                                    DEDUCE_EXACT, -1) != 0)
5712             /* Argument deduction failed.  */
5713             continue;
5714
5715           /* Instantiate the template.  */
5716           instantiation = instantiate_template (fn, targs, flags);
5717           if (instantiation == error_mark_node)
5718             /* Instantiation failed.  */
5719             continue;
5720
5721           /* See if there's a match.  */
5722           instantiation_type = TREE_TYPE (instantiation);
5723           if (is_ptrmem)
5724             instantiation_type =
5725               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
5726           else if (!is_reference)
5727             instantiation_type = build_pointer_type (instantiation_type);
5728           if (can_convert_arg (target_type, instantiation_type, instantiation))
5729             matches = tree_cons (instantiation, fn, matches);
5730         }
5731
5732       /* Now, remove all but the most specialized of the matches.  */
5733       if (matches)
5734         {
5735           tree match = most_specialized_instantiation (matches);
5736
5737           if (match != error_mark_node)
5738             matches = tree_cons (match, NULL_TREE, NULL_TREE);
5739         }
5740     }
5741
5742   /* Now we should have exactly one function in MATCHES.  */
5743   if (matches == NULL_TREE)
5744     {
5745       /* There were *no* matches.  */
5746       if (flags & tf_error)
5747         {
5748           error ("no matches converting function %qD to type %q#T",
5749                  DECL_NAME (OVL_FUNCTION (overload)),
5750                  target_type);
5751
5752           /* print_candidates expects a chain with the functions in
5753              TREE_VALUE slots, so we cons one up here (we're losing anyway,
5754              so why be clever?).  */
5755           for (; overload; overload = OVL_NEXT (overload))
5756             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
5757                                  matches);
5758
5759           print_candidates (matches);
5760         }
5761       return error_mark_node;
5762     }
5763   else if (TREE_CHAIN (matches))
5764     {
5765       /* There were too many matches.  */
5766
5767       if (flags & tf_error)
5768         {
5769           tree match;
5770
5771           error ("converting overloaded function %qD to type %q#T is ambiguous",
5772                     DECL_NAME (OVL_FUNCTION (overload)),
5773                     target_type);
5774
5775           /* Since print_candidates expects the functions in the
5776              TREE_VALUE slot, we flip them here.  */
5777           for (match = matches; match; match = TREE_CHAIN (match))
5778             TREE_VALUE (match) = TREE_PURPOSE (match);
5779
5780           print_candidates (matches);
5781         }
5782
5783       return error_mark_node;
5784     }
5785
5786   /* Good, exactly one match.  Now, convert it to the correct type.  */
5787   fn = TREE_PURPOSE (matches);
5788
5789   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
5790       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
5791     {
5792       static int explained;
5793
5794       if (!(flags & tf_error))
5795         return error_mark_node;
5796
5797       pedwarn ("assuming pointer to member %qD", fn);
5798       if (!explained)
5799         {
5800           pedwarn ("(a pointer to member can only be formed with %<&%E%>)", fn);
5801           explained = 1;
5802         }
5803     }
5804
5805   /* If we're doing overload resolution purely for the purpose of
5806      determining conversion sequences, we should not consider the
5807      function used.  If this conversion sequence is selected, the
5808      function will be marked as used at this point.  */
5809   if (!(flags & tf_conv))
5810     mark_used (fn);
5811
5812   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
5813     return build_unary_op (ADDR_EXPR, fn, 0);
5814   else
5815     {
5816       /* The target must be a REFERENCE_TYPE.  Above, build_unary_op
5817          will mark the function as addressed, but here we must do it
5818          explicitly.  */
5819       cxx_mark_addressable (fn);
5820
5821       return fn;
5822     }
5823 }
5824
5825 /* This function will instantiate the type of the expression given in
5826    RHS to match the type of LHSTYPE.  If errors exist, then return
5827    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
5828    we complain on errors.  If we are not complaining, never modify rhs,
5829    as overload resolution wants to try many possible instantiations, in
5830    the hope that at least one will work.
5831
5832    For non-recursive calls, LHSTYPE should be a function, pointer to
5833    function, or a pointer to member function.  */
5834
5835 tree
5836 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
5837 {
5838   tsubst_flags_t flags_in = flags;
5839
5840   flags &= ~tf_ptrmem_ok;
5841
5842   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
5843     {
5844       if (flags & tf_error)
5845         error ("not enough type information");
5846       return error_mark_node;
5847     }
5848
5849   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
5850     {
5851       if (same_type_p (lhstype, TREE_TYPE (rhs)))
5852         return rhs;
5853       if (flag_ms_extensions
5854           && TYPE_PTRMEMFUNC_P (lhstype)
5855           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
5856         /* Microsoft allows `A::f' to be resolved to a
5857            pointer-to-member.  */
5858         ;
5859       else
5860         {
5861           if (flags & tf_error)
5862             error ("argument of type %qT does not match %qT",
5863                    TREE_TYPE (rhs), lhstype);
5864           return error_mark_node;
5865         }
5866     }
5867
5868   if (TREE_CODE (rhs) == BASELINK)
5869     rhs = BASELINK_FUNCTIONS (rhs);
5870
5871   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
5872      deduce any type information.  */
5873   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
5874     {
5875       if (flags & tf_error)
5876         error ("not enough type information");
5877       return error_mark_node;
5878     }
5879
5880   /* We don't overwrite rhs if it is an overloaded function.
5881      Copying it would destroy the tree link.  */
5882   if (TREE_CODE (rhs) != OVERLOAD)
5883     rhs = copy_node (rhs);
5884
5885   /* This should really only be used when attempting to distinguish
5886      what sort of a pointer to function we have.  For now, any
5887      arithmetic operation which is not supported on pointers
5888      is rejected as an error.  */
5889
5890   switch (TREE_CODE (rhs))
5891     {
5892     case TYPE_EXPR:
5893     case CONVERT_EXPR:
5894     case SAVE_EXPR:
5895     case CONSTRUCTOR:
5896       gcc_unreachable ();
5897
5898     case INDIRECT_REF:
5899     case ARRAY_REF:
5900       {
5901         tree new_rhs;
5902
5903         new_rhs = instantiate_type (build_pointer_type (lhstype),
5904                                     TREE_OPERAND (rhs, 0), flags);
5905         if (new_rhs == error_mark_node)
5906           return error_mark_node;
5907
5908         TREE_TYPE (rhs) = lhstype;
5909         TREE_OPERAND (rhs, 0) = new_rhs;
5910         return rhs;
5911       }
5912
5913     case NOP_EXPR:
5914       rhs = copy_node (TREE_OPERAND (rhs, 0));
5915       TREE_TYPE (rhs) = unknown_type_node;
5916       return instantiate_type (lhstype, rhs, flags);
5917
5918     case COMPONENT_REF:
5919       {
5920         tree member = TREE_OPERAND (rhs, 1);
5921
5922         member = instantiate_type (lhstype, member, flags);
5923         if (member != error_mark_node
5924             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
5925           /* Do not lose object's side effects.  */
5926           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
5927                          TREE_OPERAND (rhs, 0), member);
5928         return member;
5929       }
5930
5931     case OFFSET_REF:
5932       rhs = TREE_OPERAND (rhs, 1);
5933       if (BASELINK_P (rhs))
5934         return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags_in);
5935
5936       /* This can happen if we are forming a pointer-to-member for a
5937          member template.  */
5938       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
5939
5940       /* Fall through.  */
5941
5942     case TEMPLATE_ID_EXPR:
5943       {
5944         tree fns = TREE_OPERAND (rhs, 0);
5945         tree args = TREE_OPERAND (rhs, 1);
5946
5947         return
5948           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
5949                                                   /*template_only=*/true,
5950                                                   args);
5951       }
5952
5953     case OVERLOAD:
5954     case FUNCTION_DECL:
5955       return
5956         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
5957                                                 /*template_only=*/false,
5958                                                 /*explicit_targs=*/NULL_TREE);
5959
5960     case CALL_EXPR:
5961       /* This is too hard for now.  */
5962       gcc_unreachable ();
5963
5964     case PLUS_EXPR:
5965     case MINUS_EXPR:
5966     case COMPOUND_EXPR:
5967       TREE_OPERAND (rhs, 0)
5968         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
5969       if (TREE_OPERAND (rhs, 0) == error_mark_node)
5970         return error_mark_node;
5971       TREE_OPERAND (rhs, 1)
5972         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
5973       if (TREE_OPERAND (rhs, 1) == error_mark_node)
5974         return error_mark_node;
5975
5976       TREE_TYPE (rhs) = lhstype;
5977       return rhs;
5978
5979     case MULT_EXPR:
5980     case TRUNC_DIV_EXPR:
5981     case FLOOR_DIV_EXPR:
5982     case CEIL_DIV_EXPR:
5983     case ROUND_DIV_EXPR:
5984     case RDIV_EXPR:
5985     case TRUNC_MOD_EXPR:
5986     case FLOOR_MOD_EXPR:
5987     case CEIL_MOD_EXPR:
5988     case ROUND_MOD_EXPR:
5989     case FIX_ROUND_EXPR:
5990     case FIX_FLOOR_EXPR:
5991     case FIX_CEIL_EXPR:
5992     case FIX_TRUNC_EXPR:
5993     case FLOAT_EXPR:
5994     case NEGATE_EXPR:
5995     case ABS_EXPR:
5996     case MAX_EXPR:
5997     case MIN_EXPR:
5998
5999     case BIT_AND_EXPR:
6000     case BIT_IOR_EXPR:
6001     case BIT_XOR_EXPR:
6002     case LSHIFT_EXPR:
6003     case RSHIFT_EXPR:
6004     case LROTATE_EXPR:
6005     case RROTATE_EXPR:
6006
6007     case PREINCREMENT_EXPR:
6008     case PREDECREMENT_EXPR:
6009     case POSTINCREMENT_EXPR:
6010     case POSTDECREMENT_EXPR:
6011       if (flags & tf_error)
6012         error ("invalid operation on uninstantiated type");
6013       return error_mark_node;
6014
6015     case TRUTH_AND_EXPR:
6016     case TRUTH_OR_EXPR:
6017     case TRUTH_XOR_EXPR:
6018     case LT_EXPR:
6019     case LE_EXPR:
6020     case GT_EXPR:
6021     case GE_EXPR:
6022     case EQ_EXPR:
6023     case NE_EXPR:
6024     case TRUTH_ANDIF_EXPR:
6025     case TRUTH_ORIF_EXPR:
6026     case TRUTH_NOT_EXPR:
6027       if (flags & tf_error)
6028         error ("not enough type information");
6029       return error_mark_node;
6030
6031     case COND_EXPR:
6032       if (type_unknown_p (TREE_OPERAND (rhs, 0)))
6033         {
6034           if (flags & tf_error)
6035             error ("not enough type information");
6036           return error_mark_node;
6037         }
6038       TREE_OPERAND (rhs, 1)
6039         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6040       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6041         return error_mark_node;
6042       TREE_OPERAND (rhs, 2)
6043         = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), flags);
6044       if (TREE_OPERAND (rhs, 2) == error_mark_node)
6045         return error_mark_node;
6046
6047       TREE_TYPE (rhs) = lhstype;
6048       return rhs;
6049
6050     case MODIFY_EXPR:
6051       TREE_OPERAND (rhs, 1)
6052         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6053       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6054         return error_mark_node;
6055
6056       TREE_TYPE (rhs) = lhstype;
6057       return rhs;
6058
6059     case ADDR_EXPR:
6060     {
6061       if (PTRMEM_OK_P (rhs))
6062         flags |= tf_ptrmem_ok;
6063
6064       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6065     }
6066
6067     case ERROR_MARK:
6068       return error_mark_node;
6069
6070     default:
6071       gcc_unreachable ();
6072     }
6073   return error_mark_node;
6074 }
6075 \f
6076 /* Return the name of the virtual function pointer field
6077    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6078    this may have to look back through base types to find the
6079    ultimate field name.  (For single inheritance, these could
6080    all be the same name.  Who knows for multiple inheritance).  */
6081
6082 static tree
6083 get_vfield_name (tree type)
6084 {
6085   tree binfo, base_binfo;
6086   char *buf;
6087
6088   for (binfo = TYPE_BINFO (type);
6089        BINFO_N_BASE_BINFOS (binfo);
6090        binfo = base_binfo)
6091     {
6092       base_binfo = BINFO_BASE_BINFO (binfo, 0);
6093
6094       if (BINFO_VIRTUAL_P (base_binfo)
6095           || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6096         break;
6097     }
6098
6099   type = BINFO_TYPE (binfo);
6100   buf = alloca (sizeof (VFIELD_NAME_FORMAT) + TYPE_NAME_LENGTH (type) + 2);
6101   sprintf (buf, VFIELD_NAME_FORMAT,
6102            IDENTIFIER_POINTER (constructor_name (type)));
6103   return get_identifier (buf);
6104 }
6105
6106 void
6107 print_class_statistics (void)
6108 {
6109 #ifdef GATHER_STATISTICS
6110   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6111   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6112   if (n_vtables)
6113     {
6114       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6115                n_vtables, n_vtable_searches);
6116       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6117                n_vtable_entries, n_vtable_elems);
6118     }
6119 #endif
6120 }
6121
6122 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6123    according to [class]:
6124                                           The class-name is also inserted
6125    into  the scope of the class itself.  For purposes of access checking,
6126    the inserted class name is treated as if it were a public member name.  */
6127
6128 void
6129 build_self_reference (void)
6130 {
6131   tree name = constructor_name (current_class_type);
6132   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6133   tree saved_cas;
6134
6135   DECL_NONLOCAL (value) = 1;
6136   DECL_CONTEXT (value) = current_class_type;
6137   DECL_ARTIFICIAL (value) = 1;
6138   SET_DECL_SELF_REFERENCE_P (value);
6139
6140   if (processing_template_decl)
6141     value = push_template_decl (value);
6142
6143   saved_cas = current_access_specifier;
6144   current_access_specifier = access_public_node;
6145   finish_member_declaration (value);
6146   current_access_specifier = saved_cas;
6147 }
6148
6149 /* Returns 1 if TYPE contains only padding bytes.  */
6150
6151 int
6152 is_empty_class (tree type)
6153 {
6154   if (type == error_mark_node)
6155     return 0;
6156
6157   if (! IS_AGGR_TYPE (type))
6158     return 0;
6159
6160   /* In G++ 3.2, whether or not a class was empty was determined by
6161      looking at its size.  */
6162   if (abi_version_at_least (2))
6163     return CLASSTYPE_EMPTY_P (type);
6164   else
6165     return integer_zerop (CLASSTYPE_SIZE (type));
6166 }
6167
6168 /* Returns true if TYPE contains an empty class.  */
6169
6170 static bool
6171 contains_empty_class_p (tree type)
6172 {
6173   if (is_empty_class (type))
6174     return true;
6175   if (CLASS_TYPE_P (type))
6176     {
6177       tree field;
6178       tree binfo;
6179       tree base_binfo;
6180       int i;
6181
6182       for (binfo = TYPE_BINFO (type), i = 0;
6183            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6184         if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6185           return true;
6186       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6187         if (TREE_CODE (field) == FIELD_DECL
6188             && !DECL_ARTIFICIAL (field)
6189             && is_empty_class (TREE_TYPE (field)))
6190           return true;
6191     }
6192   else if (TREE_CODE (type) == ARRAY_TYPE)
6193     return contains_empty_class_p (TREE_TYPE (type));
6194   return false;
6195 }
6196
6197 /* Find the enclosing class of the given NODE.  NODE can be a *_DECL or
6198    a *_TYPE node.  NODE can also be a local class.  */
6199
6200 tree
6201 get_enclosing_class (tree type)
6202 {
6203   tree node = type;
6204
6205   while (node && TREE_CODE (node) != NAMESPACE_DECL)
6206     {
6207       switch (TREE_CODE_CLASS (TREE_CODE (node)))
6208         {
6209         case tcc_declaration:
6210           node = DECL_CONTEXT (node);
6211           break;
6212
6213         case tcc_type:
6214           if (node != type)
6215             return node;
6216           node = TYPE_CONTEXT (node);
6217           break;
6218
6219         default:
6220           gcc_unreachable ();
6221         }
6222     }
6223   return NULL_TREE;
6224 }
6225
6226 /* Note that NAME was looked up while the current class was being
6227    defined and that the result of that lookup was DECL.  */
6228
6229 void
6230 maybe_note_name_used_in_class (tree name, tree decl)
6231 {
6232   splay_tree names_used;
6233
6234   /* If we're not defining a class, there's nothing to do.  */
6235   if (!(innermost_scope_kind() == sk_class
6236         && TYPE_BEING_DEFINED (current_class_type)))
6237     return;
6238
6239   /* If there's already a binding for this NAME, then we don't have
6240      anything to worry about.  */
6241   if (lookup_member (current_class_type, name,
6242                      /*protect=*/0, /*want_type=*/false))
6243     return;
6244
6245   if (!current_class_stack[current_class_depth - 1].names_used)
6246     current_class_stack[current_class_depth - 1].names_used
6247       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6248   names_used = current_class_stack[current_class_depth - 1].names_used;
6249
6250   splay_tree_insert (names_used,
6251                      (splay_tree_key) name,
6252                      (splay_tree_value) decl);
6253 }
6254
6255 /* Note that NAME was declared (as DECL) in the current class.  Check
6256    to see that the declaration is valid.  */
6257
6258 void
6259 note_name_declared_in_class (tree name, tree decl)
6260 {
6261   splay_tree names_used;
6262   splay_tree_node n;
6263
6264   /* Look to see if we ever used this name.  */
6265   names_used
6266     = current_class_stack[current_class_depth - 1].names_used;
6267   if (!names_used)
6268     return;
6269
6270   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6271   if (n)
6272     {
6273       /* [basic.scope.class]
6274
6275          A name N used in a class S shall refer to the same declaration
6276          in its context and when re-evaluated in the completed scope of
6277          S.  */
6278       error ("declaration of %q#D", decl);
6279       cp_error_at ("changes meaning of %qD from %q+#D",
6280                    DECL_NAME (OVL_CURRENT (decl)),
6281                    (tree) n->value);
6282     }
6283 }
6284
6285 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6286    Secondary vtables are merged with primary vtables; this function
6287    will return the VAR_DECL for the primary vtable.  */
6288
6289 tree
6290 get_vtbl_decl_for_binfo (tree binfo)
6291 {
6292   tree decl;
6293
6294   decl = BINFO_VTABLE (binfo);
6295   if (decl && TREE_CODE (decl) == PLUS_EXPR)
6296     {
6297       gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6298       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6299     }
6300   if (decl)
6301     gcc_assert (TREE_CODE (decl) == VAR_DECL);
6302   return decl;
6303 }
6304
6305
6306 /* Returns the binfo for the primary base of BINFO.  If the resulting
6307    BINFO is a virtual base, and it is inherited elsewhere in the
6308    hierarchy, then the returned binfo might not be the primary base of
6309    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6310    BINFO_LOST_PRIMARY_P to be sure.  */
6311
6312 tree
6313 get_primary_binfo (tree binfo)
6314 {
6315   tree primary_base;
6316   tree result;
6317
6318   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6319   if (!primary_base)
6320     return NULL_TREE;
6321
6322   result = copied_binfo (primary_base, binfo);
6323   return result;
6324 }
6325
6326 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6327
6328 static int
6329 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6330 {
6331   if (!indented_p)
6332     fprintf (stream, "%*s", indent, "");
6333   return 1;
6334 }
6335
6336 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6337    INDENT should be zero when called from the top level; it is
6338    incremented recursively.  IGO indicates the next expected BINFO in
6339    inheritance graph ordering.  */
6340
6341 static tree
6342 dump_class_hierarchy_r (FILE *stream,
6343                         int flags,
6344                         tree binfo,
6345                         tree igo,
6346                         int indent)
6347 {
6348   int indented = 0;
6349   tree base_binfo;
6350   int i;
6351
6352   indented = maybe_indent_hierarchy (stream, indent, 0);
6353   fprintf (stream, "%s (0x%lx) ",
6354            type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6355            (unsigned long) binfo);
6356   if (binfo != igo)
6357     {
6358       fprintf (stream, "alternative-path\n");
6359       return igo;
6360     }
6361   igo = TREE_CHAIN (binfo);
6362
6363   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6364            tree_low_cst (BINFO_OFFSET (binfo), 0));
6365   if (is_empty_class (BINFO_TYPE (binfo)))
6366     fprintf (stream, " empty");
6367   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6368     fprintf (stream, " nearly-empty");
6369   if (BINFO_VIRTUAL_P (binfo))
6370     fprintf (stream, " virtual");
6371   fprintf (stream, "\n");
6372
6373   indented = 0;
6374   if (BINFO_PRIMARY_P (binfo))
6375     {
6376       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6377       fprintf (stream, " primary-for %s (0x%lx)",
6378                type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
6379                                TFF_PLAIN_IDENTIFIER),
6380                (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
6381     }
6382   if (BINFO_LOST_PRIMARY_P (binfo))
6383     {
6384       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6385       fprintf (stream, " lost-primary");
6386     }
6387   if (indented)
6388     fprintf (stream, "\n");
6389
6390   if (!(flags & TDF_SLIM))
6391     {
6392       int indented = 0;
6393
6394       if (BINFO_SUBVTT_INDEX (binfo))
6395         {
6396           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6397           fprintf (stream, " subvttidx=%s",
6398                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6399                                    TFF_PLAIN_IDENTIFIER));
6400         }
6401       if (BINFO_VPTR_INDEX (binfo))
6402         {
6403           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6404           fprintf (stream, " vptridx=%s",
6405                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6406                                    TFF_PLAIN_IDENTIFIER));
6407         }
6408       if (BINFO_VPTR_FIELD (binfo))
6409         {
6410           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6411           fprintf (stream, " vbaseoffset=%s",
6412                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6413                                    TFF_PLAIN_IDENTIFIER));
6414         }
6415       if (BINFO_VTABLE (binfo))
6416         {
6417           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6418           fprintf (stream, " vptr=%s",
6419                    expr_as_string (BINFO_VTABLE (binfo),
6420                                    TFF_PLAIN_IDENTIFIER));
6421         }
6422
6423       if (indented)
6424         fprintf (stream, "\n");
6425     }
6426
6427   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
6428     igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
6429
6430   return igo;
6431 }
6432
6433 /* Dump the BINFO hierarchy for T.  */
6434
6435 static void
6436 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6437 {
6438   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6439   fprintf (stream, "   size=%lu align=%lu\n",
6440            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6441            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6442   fprintf (stream, "   base size=%lu base align=%lu\n",
6443            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6444                            / BITS_PER_UNIT),
6445            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6446                            / BITS_PER_UNIT));
6447   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6448   fprintf (stream, "\n");
6449 }
6450
6451 /* Debug interface to hierarchy dumping.  */
6452
6453 extern void
6454 debug_class (tree t)
6455 {
6456   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6457 }
6458
6459 static void
6460 dump_class_hierarchy (tree t)
6461 {
6462   int flags;
6463   FILE *stream = dump_begin (TDI_class, &flags);
6464
6465   if (stream)
6466     {
6467       dump_class_hierarchy_1 (stream, flags, t);
6468       dump_end (TDI_class, stream);
6469     }
6470 }
6471
6472 static void
6473 dump_array (FILE * stream, tree decl)
6474 {
6475   tree inits;
6476   int ix;
6477   HOST_WIDE_INT elt;
6478   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6479
6480   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6481          / BITS_PER_UNIT);
6482   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6483   fprintf (stream, " %s entries",
6484            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6485                            TFF_PLAIN_IDENTIFIER));
6486   fprintf (stream, "\n");
6487
6488   for (ix = 0, inits = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
6489        inits; ix++, inits = TREE_CHAIN (inits))
6490     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6491              expr_as_string (TREE_VALUE (inits), TFF_PLAIN_IDENTIFIER));
6492 }
6493
6494 static void
6495 dump_vtable (tree t, tree binfo, tree vtable)
6496 {
6497   int flags;
6498   FILE *stream = dump_begin (TDI_class, &flags);
6499
6500   if (!stream)
6501     return;
6502
6503   if (!(flags & TDF_SLIM))
6504     {
6505       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6506
6507       fprintf (stream, "%s for %s",
6508                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6509                type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
6510       if (ctor_vtbl_p)
6511         {
6512           if (!BINFO_VIRTUAL_P (binfo))
6513             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6514           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6515         }
6516       fprintf (stream, "\n");
6517       dump_array (stream, vtable);
6518       fprintf (stream, "\n");
6519     }
6520
6521   dump_end (TDI_class, stream);
6522 }
6523
6524 static void
6525 dump_vtt (tree t, tree vtt)
6526 {
6527   int flags;
6528   FILE *stream = dump_begin (TDI_class, &flags);
6529
6530   if (!stream)
6531     return;
6532
6533   if (!(flags & TDF_SLIM))
6534     {
6535       fprintf (stream, "VTT for %s\n",
6536                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6537       dump_array (stream, vtt);
6538       fprintf (stream, "\n");
6539     }
6540
6541   dump_end (TDI_class, stream);
6542 }
6543
6544 /* Dump a function or thunk and its thunkees.  */
6545
6546 static void
6547 dump_thunk (FILE *stream, int indent, tree thunk)
6548 {
6549   static const char spaces[] = "        ";
6550   tree name = DECL_NAME (thunk);
6551   tree thunks;
6552
6553   fprintf (stream, "%.*s%p %s %s", indent, spaces,
6554            (void *)thunk,
6555            !DECL_THUNK_P (thunk) ? "function"
6556            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6557            name ? IDENTIFIER_POINTER (name) : "<unset>");
6558   if (DECL_THUNK_P (thunk))
6559     {
6560       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6561       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6562
6563       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6564       if (!virtual_adjust)
6565         /*NOP*/;
6566       else if (DECL_THIS_THUNK_P (thunk))
6567         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
6568                  tree_low_cst (virtual_adjust, 0));
6569       else
6570         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6571                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6572                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6573       if (THUNK_ALIAS (thunk))
6574         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6575     }
6576   fprintf (stream, "\n");
6577   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6578     dump_thunk (stream, indent + 2, thunks);
6579 }
6580
6581 /* Dump the thunks for FN.  */
6582
6583 extern void
6584 debug_thunks (tree fn)
6585 {
6586   dump_thunk (stderr, 0, fn);
6587 }
6588
6589 /* Virtual function table initialization.  */
6590
6591 /* Create all the necessary vtables for T and its base classes.  */
6592
6593 static void
6594 finish_vtbls (tree t)
6595 {
6596   tree list;
6597   tree vbase;
6598
6599   /* We lay out the primary and secondary vtables in one contiguous
6600      vtable.  The primary vtable is first, followed by the non-virtual
6601      secondary vtables in inheritance graph order.  */
6602   list = build_tree_list (BINFO_VTABLE (TYPE_BINFO (t)), NULL_TREE);
6603   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6604                          TYPE_BINFO (t), t, list);
6605
6606   /* Then come the virtual bases, also in inheritance graph order.  */
6607   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6608     {
6609       if (!BINFO_VIRTUAL_P (vbase))
6610         continue;
6611       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6612     }
6613
6614   if (BINFO_VTABLE (TYPE_BINFO (t)))
6615     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6616 }
6617
6618 /* Initialize the vtable for BINFO with the INITS.  */
6619
6620 static void
6621 initialize_vtable (tree binfo, tree inits)
6622 {
6623   tree decl;
6624
6625   layout_vtable_decl (binfo, list_length (inits));
6626   decl = get_vtbl_decl_for_binfo (binfo);
6627   initialize_artificial_var (decl, inits);
6628   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6629 }
6630
6631 /* Build the VTT (virtual table table) for T.
6632    A class requires a VTT if it has virtual bases.
6633
6634    This holds
6635    1 - primary virtual pointer for complete object T
6636    2 - secondary VTTs for each direct non-virtual base of T which requires a
6637        VTT
6638    3 - secondary virtual pointers for each direct or indirect base of T which
6639        has virtual bases or is reachable via a virtual path from T.
6640    4 - secondary VTTs for each direct or indirect virtual base of T.
6641
6642    Secondary VTTs look like complete object VTTs without part 4.  */
6643
6644 static void
6645 build_vtt (tree t)
6646 {
6647   tree inits;
6648   tree type;
6649   tree vtt;
6650   tree index;
6651
6652   /* Build up the initializers for the VTT.  */
6653   inits = NULL_TREE;
6654   index = size_zero_node;
6655   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6656
6657   /* If we didn't need a VTT, we're done.  */
6658   if (!inits)
6659     return;
6660
6661   /* Figure out the type of the VTT.  */
6662   type = build_index_type (size_int (list_length (inits) - 1));
6663   type = build_cplus_array_type (const_ptr_type_node, type);
6664
6665   /* Now, build the VTT object itself.  */
6666   vtt = build_vtable (t, get_vtt_name (t), type);
6667   initialize_artificial_var (vtt, inits);
6668   /* Add the VTT to the vtables list.  */
6669   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6670   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6671
6672   dump_vtt (t, vtt);
6673 }
6674
6675 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6676    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6677    and CHAIN the vtable pointer for this binfo after construction is
6678    complete.  VALUE can also be another BINFO, in which case we recurse.  */
6679
6680 static tree
6681 binfo_ctor_vtable (tree binfo)
6682 {
6683   tree vt;
6684
6685   while (1)
6686     {
6687       vt = BINFO_VTABLE (binfo);
6688       if (TREE_CODE (vt) == TREE_LIST)
6689         vt = TREE_VALUE (vt);
6690       if (TREE_CODE (vt) == TREE_BINFO)
6691         binfo = vt;
6692       else
6693         break;
6694     }
6695
6696   return vt;
6697 }
6698
6699 /* Data for secondary VTT initialization.  */
6700 typedef struct secondary_vptr_vtt_init_data_s
6701 {
6702   /* Is this the primary VTT? */
6703   bool top_level_p;
6704
6705   /* Current index into the VTT.  */
6706   tree index;
6707
6708   /* TREE_LIST of initializers built up.  */
6709   tree inits;
6710
6711   /* The type being constructed by this secondary VTT.  */
6712   tree type_being_constructed;
6713 } secondary_vptr_vtt_init_data;
6714
6715 /* Recursively build the VTT-initializer for BINFO (which is in the
6716    hierarchy dominated by T).  INITS points to the end of the initializer
6717    list to date.  INDEX is the VTT index where the next element will be
6718    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6719    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
6720    for virtual bases of T. When it is not so, we build the constructor
6721    vtables for the BINFO-in-T variant.  */
6722
6723 static tree *
6724 build_vtt_inits (tree binfo, tree t, tree *inits, tree *index)
6725 {
6726   int i;
6727   tree b;
6728   tree init;
6729   tree secondary_vptrs;
6730   secondary_vptr_vtt_init_data data;
6731   int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
6732
6733   /* We only need VTTs for subobjects with virtual bases.  */
6734   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
6735     return inits;
6736
6737   /* We need to use a construction vtable if this is not the primary
6738      VTT.  */
6739   if (!top_level_p)
6740     {
6741       build_ctor_vtbl_group (binfo, t);
6742
6743       /* Record the offset in the VTT where this sub-VTT can be found.  */
6744       BINFO_SUBVTT_INDEX (binfo) = *index;
6745     }
6746
6747   /* Add the address of the primary vtable for the complete object.  */
6748   init = binfo_ctor_vtable (binfo);
6749   *inits = build_tree_list (NULL_TREE, init);
6750   inits = &TREE_CHAIN (*inits);
6751   if (top_level_p)
6752     {
6753       gcc_assert (!BINFO_VPTR_INDEX (binfo));
6754       BINFO_VPTR_INDEX (binfo) = *index;
6755     }
6756   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
6757
6758   /* Recursively add the secondary VTTs for non-virtual bases.  */
6759   for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
6760     if (!BINFO_VIRTUAL_P (b))
6761       inits = build_vtt_inits (b, t, inits, index);
6762
6763   /* Add secondary virtual pointers for all subobjects of BINFO with
6764      either virtual bases or reachable along a virtual path, except
6765      subobjects that are non-virtual primary bases.  */
6766   data.top_level_p = top_level_p;
6767   data.index = *index;
6768   data.inits = NULL;
6769   data.type_being_constructed = BINFO_TYPE (binfo);
6770
6771   dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
6772
6773   *index = data.index;
6774
6775   /* The secondary vptrs come back in reverse order.  After we reverse
6776      them, and add the INITS, the last init will be the first element
6777      of the chain.  */
6778   secondary_vptrs = data.inits;
6779   if (secondary_vptrs)
6780     {
6781       *inits = nreverse (secondary_vptrs);
6782       inits = &TREE_CHAIN (secondary_vptrs);
6783       gcc_assert (*inits == NULL_TREE);
6784     }
6785
6786   if (top_level_p)
6787     /* Add the secondary VTTs for virtual bases in inheritance graph
6788        order.  */
6789     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
6790       {
6791         if (!BINFO_VIRTUAL_P (b))
6792           continue;
6793
6794         inits = build_vtt_inits (b, t, inits, index);
6795       }
6796   else
6797     /* Remove the ctor vtables we created.  */
6798     dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
6799
6800   return inits;
6801 }
6802
6803 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo for the base
6804    in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure.  */
6805
6806 static tree
6807 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
6808 {
6809   secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
6810
6811   /* We don't care about bases that don't have vtables.  */
6812   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
6813     return dfs_skip_bases;
6814
6815   /* We're only interested in proper subobjects of the type being
6816      constructed.  */
6817   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
6818     return NULL_TREE;
6819
6820   /* We're only interested in bases with virtual bases or reachable
6821      via a virtual path from the type being constructed.  */
6822   if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
6823         || binfo_via_virtual (binfo, data->type_being_constructed)))
6824     return dfs_skip_bases;
6825
6826   /* We're not interested in non-virtual primary bases.  */
6827   if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
6828     return NULL_TREE;
6829
6830   /* Record the index where this secondary vptr can be found.  */
6831   if (data->top_level_p)
6832     {
6833       gcc_assert (!BINFO_VPTR_INDEX (binfo));
6834       BINFO_VPTR_INDEX (binfo) = data->index;
6835
6836       if (BINFO_VIRTUAL_P (binfo))
6837         {
6838           /* It's a primary virtual base, and this is not a
6839              construction vtable.  Find the base this is primary of in
6840              the inheritance graph, and use that base's vtable
6841              now.  */
6842           while (BINFO_PRIMARY_P (binfo))
6843             binfo = BINFO_INHERITANCE_CHAIN (binfo);
6844         }
6845     }
6846
6847   /* Add the initializer for the secondary vptr itself.  */
6848   data->inits = tree_cons (NULL_TREE, binfo_ctor_vtable (binfo), data->inits);
6849
6850   /* Advance the vtt index.  */
6851   data->index = size_binop (PLUS_EXPR, data->index,
6852                             TYPE_SIZE_UNIT (ptr_type_node));
6853
6854   return NULL_TREE;
6855 }
6856
6857 /* Called from build_vtt_inits via dfs_walk. After building
6858    constructor vtables and generating the sub-vtt from them, we need
6859    to restore the BINFO_VTABLES that were scribbled on.  DATA is the
6860    binfo of the base whose sub vtt was generated.  */
6861
6862 static tree
6863 dfs_fixup_binfo_vtbls (tree binfo, void* data)
6864 {
6865   tree vtable = BINFO_VTABLE (binfo);
6866
6867   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
6868     /* If this class has no vtable, none of its bases do.  */
6869     return dfs_skip_bases;
6870
6871   if (!vtable)
6872     /* This might be a primary base, so have no vtable in this
6873        hierarchy.  */
6874     return NULL_TREE;
6875
6876   /* If we scribbled the construction vtable vptr into BINFO, clear it
6877      out now.  */
6878   if (TREE_CODE (vtable) == TREE_LIST
6879       && (TREE_PURPOSE (vtable) == (tree) data))
6880     BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
6881
6882   return NULL_TREE;
6883 }
6884
6885 /* Build the construction vtable group for BINFO which is in the
6886    hierarchy dominated by T.  */
6887
6888 static void
6889 build_ctor_vtbl_group (tree binfo, tree t)
6890 {
6891   tree list;
6892   tree type;
6893   tree vtbl;
6894   tree inits;
6895   tree id;
6896   tree vbase;
6897
6898   /* See if we've already created this construction vtable group.  */
6899   id = mangle_ctor_vtbl_for_type (t, binfo);
6900   if (IDENTIFIER_GLOBAL_VALUE (id))
6901     return;
6902
6903   gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
6904   /* Build a version of VTBL (with the wrong type) for use in
6905      constructing the addresses of secondary vtables in the
6906      construction vtable group.  */
6907   vtbl = build_vtable (t, id, ptr_type_node);
6908   DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
6909   list = build_tree_list (vtbl, NULL_TREE);
6910   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
6911                          binfo, t, list);
6912
6913   /* Add the vtables for each of our virtual bases using the vbase in T
6914      binfo.  */
6915   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
6916        vbase;
6917        vbase = TREE_CHAIN (vbase))
6918     {
6919       tree b;
6920
6921       if (!BINFO_VIRTUAL_P (vbase))
6922         continue;
6923       b = copied_binfo (vbase, binfo);
6924
6925       accumulate_vtbl_inits (b, vbase, binfo, t, list);
6926     }
6927   inits = TREE_VALUE (list);
6928
6929   /* Figure out the type of the construction vtable.  */
6930   type = build_index_type (size_int (list_length (inits) - 1));
6931   type = build_cplus_array_type (vtable_entry_type, type);
6932   TREE_TYPE (vtbl) = type;
6933
6934   /* Initialize the construction vtable.  */
6935   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
6936   initialize_artificial_var (vtbl, inits);
6937   dump_vtable (t, binfo, vtbl);
6938 }
6939
6940 /* Add the vtbl initializers for BINFO (and its bases other than
6941    non-virtual primaries) to the list of INITS.  BINFO is in the
6942    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
6943    the constructor the vtbl inits should be accumulated for. (If this
6944    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
6945    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
6946    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
6947    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
6948    but are not necessarily the same in terms of layout.  */
6949
6950 static void
6951 accumulate_vtbl_inits (tree binfo,
6952                        tree orig_binfo,
6953                        tree rtti_binfo,
6954                        tree t,
6955                        tree inits)
6956 {
6957   int i;
6958   tree base_binfo;
6959   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
6960
6961   gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
6962
6963   /* If it doesn't have a vptr, we don't do anything.  */
6964   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
6965     return;
6966
6967   /* If we're building a construction vtable, we're not interested in
6968      subobjects that don't require construction vtables.  */
6969   if (ctor_vtbl_p
6970       && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
6971       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
6972     return;
6973
6974   /* Build the initializers for the BINFO-in-T vtable.  */
6975   TREE_VALUE (inits)
6976     = chainon (TREE_VALUE (inits),
6977                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
6978                                           rtti_binfo, t, inits));
6979
6980   /* Walk the BINFO and its bases.  We walk in preorder so that as we
6981      initialize each vtable we can figure out at what offset the
6982      secondary vtable lies from the primary vtable.  We can't use
6983      dfs_walk here because we need to iterate through bases of BINFO
6984      and RTTI_BINFO simultaneously.  */
6985   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6986     {
6987       /* Skip virtual bases.  */
6988       if (BINFO_VIRTUAL_P (base_binfo))
6989         continue;
6990       accumulate_vtbl_inits (base_binfo,
6991                              BINFO_BASE_BINFO (orig_binfo, i),
6992                              rtti_binfo, t,
6993                              inits);
6994     }
6995 }
6996
6997 /* Called from accumulate_vtbl_inits.  Returns the initializers for
6998    the BINFO vtable.  */
6999
7000 static tree
7001 dfs_accumulate_vtbl_inits (tree binfo,
7002                            tree orig_binfo,
7003                            tree rtti_binfo,
7004                            tree t,
7005                            tree l)
7006 {
7007   tree inits = NULL_TREE;
7008   tree vtbl = NULL_TREE;
7009   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7010
7011   if (ctor_vtbl_p
7012       && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7013     {
7014       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7015          primary virtual base.  If it is not the same primary in
7016          the hierarchy of T, we'll need to generate a ctor vtable
7017          for it, to place at its location in T.  If it is the same
7018          primary, we still need a VTT entry for the vtable, but it
7019          should point to the ctor vtable for the base it is a
7020          primary for within the sub-hierarchy of RTTI_BINFO.
7021
7022          There are three possible cases:
7023
7024          1) We are in the same place.
7025          2) We are a primary base within a lost primary virtual base of
7026          RTTI_BINFO.
7027          3) We are primary to something not a base of RTTI_BINFO.  */
7028
7029       tree b;
7030       tree last = NULL_TREE;
7031
7032       /* First, look through the bases we are primary to for RTTI_BINFO
7033          or a virtual base.  */
7034       b = binfo;
7035       while (BINFO_PRIMARY_P (b))
7036         {
7037           b = BINFO_INHERITANCE_CHAIN (b);
7038           last = b;
7039           if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7040             goto found;
7041         }
7042       /* If we run out of primary links, keep looking down our
7043          inheritance chain; we might be an indirect primary.  */
7044       for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7045         if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7046           break;
7047     found:
7048
7049       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7050          base B and it is a base of RTTI_BINFO, this is case 2.  In
7051          either case, we share our vtable with LAST, i.e. the
7052          derived-most base within B of which we are a primary.  */
7053       if (b == rtti_binfo
7054           || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7055         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7056            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7057            binfo_ctor_vtable after everything's been set up.  */
7058         vtbl = last;
7059
7060       /* Otherwise, this is case 3 and we get our own.  */
7061     }
7062   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7063     return inits;
7064
7065   if (!vtbl)
7066     {
7067       tree index;
7068       int non_fn_entries;
7069
7070       /* Compute the initializer for this vtable.  */
7071       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7072                                       &non_fn_entries);
7073
7074       /* Figure out the position to which the VPTR should point.  */
7075       vtbl = TREE_PURPOSE (l);
7076       vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, vtbl);
7077       index = size_binop (PLUS_EXPR,
7078                           size_int (non_fn_entries),
7079                           size_int (list_length (TREE_VALUE (l))));
7080       index = size_binop (MULT_EXPR,
7081                           TYPE_SIZE_UNIT (vtable_entry_type),
7082                           index);
7083       vtbl = build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7084     }
7085
7086   if (ctor_vtbl_p)
7087     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7088        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7089        straighten this out.  */
7090     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7091   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7092     inits = NULL_TREE;
7093   else
7094      /* For an ordinary vtable, set BINFO_VTABLE.  */
7095     BINFO_VTABLE (binfo) = vtbl;
7096
7097   return inits;
7098 }
7099
7100 /* Construct the initializer for BINFO's virtual function table.  BINFO
7101    is part of the hierarchy dominated by T.  If we're building a
7102    construction vtable, the ORIG_BINFO is the binfo we should use to
7103    find the actual function pointers to put in the vtable - but they
7104    can be overridden on the path to most-derived in the graph that
7105    ORIG_BINFO belongs.  Otherwise,
7106    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7107    BINFO that should be indicated by the RTTI information in the
7108    vtable; it will be a base class of T, rather than T itself, if we
7109    are building a construction vtable.
7110
7111    The value returned is a TREE_LIST suitable for wrapping in a
7112    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7113    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7114    number of non-function entries in the vtable.
7115
7116    It might seem that this function should never be called with a
7117    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7118    base is always subsumed by a derived class vtable.  However, when
7119    we are building construction vtables, we do build vtables for
7120    primary bases; we need these while the primary base is being
7121    constructed.  */
7122
7123 static tree
7124 build_vtbl_initializer (tree binfo,
7125                         tree orig_binfo,
7126                         tree t,
7127                         tree rtti_binfo,
7128                         int* non_fn_entries_p)
7129 {
7130   tree v, b;
7131   tree vfun_inits;
7132   vtbl_init_data vid;
7133   unsigned ix;
7134   tree vbinfo;
7135   VEC (tree) *vbases;
7136
7137   /* Initialize VID.  */
7138   memset (&vid, 0, sizeof (vid));
7139   vid.binfo = binfo;
7140   vid.derived = t;
7141   vid.rtti_binfo = rtti_binfo;
7142   vid.last_init = &vid.inits;
7143   vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7144   vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7145   vid.generate_vcall_entries = true;
7146   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7147   vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7148
7149   /* Add entries to the vtable for RTTI.  */
7150   build_rtti_vtbl_entries (binfo, &vid);
7151
7152   /* Create an array for keeping track of the functions we've
7153      processed.  When we see multiple functions with the same
7154      signature, we share the vcall offsets.  */
7155   VARRAY_TREE_INIT (vid.fns, 32, "fns");
7156   /* Add the vcall and vbase offset entries.  */
7157   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7158
7159   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7160      build_vbase_offset_vtbl_entries.  */
7161   for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7162        VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7163     BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7164
7165   /* If the target requires padding between data entries, add that now.  */
7166   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7167     {
7168       tree cur, *prev;
7169
7170       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7171         {
7172           tree add = cur;
7173           int i;
7174
7175           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7176             add = tree_cons (NULL_TREE,
7177                              build1 (NOP_EXPR, vtable_entry_type,
7178                                      null_pointer_node),
7179                              add);
7180           *prev = add;
7181         }
7182     }
7183
7184   if (non_fn_entries_p)
7185     *non_fn_entries_p = list_length (vid.inits);
7186
7187   /* Go through all the ordinary virtual functions, building up
7188      initializers.  */
7189   vfun_inits = NULL_TREE;
7190   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7191     {
7192       tree delta;
7193       tree vcall_index;
7194       tree fn, fn_original;
7195       tree init = NULL_TREE;
7196
7197       fn = BV_FN (v);
7198       fn_original = fn;
7199       if (DECL_THUNK_P (fn))
7200         {
7201           if (!DECL_NAME (fn))
7202             finish_thunk (fn);
7203           if (THUNK_ALIAS (fn))
7204             {
7205               fn = THUNK_ALIAS (fn);
7206               BV_FN (v) = fn;
7207             }
7208           fn_original = THUNK_TARGET (fn);
7209         }
7210
7211       /* If the only definition of this function signature along our
7212          primary base chain is from a lost primary, this vtable slot will
7213          never be used, so just zero it out.  This is important to avoid
7214          requiring extra thunks which cannot be generated with the function.
7215
7216          We first check this in update_vtable_entry_for_fn, so we handle
7217          restored primary bases properly; we also need to do it here so we
7218          zero out unused slots in ctor vtables, rather than filling themff
7219          with erroneous values (though harmless, apart from relocation
7220          costs).  */
7221       for (b = binfo; ; b = get_primary_binfo (b))
7222         {
7223           /* We found a defn before a lost primary; go ahead as normal.  */
7224           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7225             break;
7226
7227           /* The nearest definition is from a lost primary; clear the
7228              slot.  */
7229           if (BINFO_LOST_PRIMARY_P (b))
7230             {
7231               init = size_zero_node;
7232               break;
7233             }
7234         }
7235
7236       if (! init)
7237         {
7238           /* Pull the offset for `this', and the function to call, out of
7239              the list.  */
7240           delta = BV_DELTA (v);
7241           vcall_index = BV_VCALL_INDEX (v);
7242
7243           gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7244           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7245
7246           /* You can't call an abstract virtual function; it's abstract.
7247              So, we replace these functions with __pure_virtual.  */
7248           if (DECL_PURE_VIRTUAL_P (fn_original))
7249             fn = abort_fndecl;
7250           else if (!integer_zerop (delta) || vcall_index)
7251             {
7252               fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7253               if (!DECL_NAME (fn))
7254                 finish_thunk (fn);
7255             }
7256           /* Take the address of the function, considering it to be of an
7257              appropriate generic type.  */
7258           init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7259         }
7260
7261       /* And add it to the chain of initializers.  */
7262       if (TARGET_VTABLE_USES_DESCRIPTORS)
7263         {
7264           int i;
7265           if (init == size_zero_node)
7266             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7267               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7268           else
7269             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7270               {
7271                 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7272                                      TREE_OPERAND (init, 0),
7273                                      build_int_cst (NULL_TREE, i));
7274                 TREE_CONSTANT (fdesc) = 1;
7275                 TREE_INVARIANT (fdesc) = 1;
7276
7277                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7278               }
7279         }
7280       else
7281         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7282     }
7283
7284   /* The initializers for virtual functions were built up in reverse
7285      order; straighten them out now.  */
7286   vfun_inits = nreverse (vfun_inits);
7287
7288   /* The negative offset initializers are also in reverse order.  */
7289   vid.inits = nreverse (vid.inits);
7290
7291   /* Chain the two together.  */
7292   return chainon (vid.inits, vfun_inits);
7293 }
7294
7295 /* Adds to vid->inits the initializers for the vbase and vcall
7296    offsets in BINFO, which is in the hierarchy dominated by T.  */
7297
7298 static void
7299 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7300 {
7301   tree b;
7302
7303   /* If this is a derived class, we must first create entries
7304      corresponding to the primary base class.  */
7305   b = get_primary_binfo (binfo);
7306   if (b)
7307     build_vcall_and_vbase_vtbl_entries (b, vid);
7308
7309   /* Add the vbase entries for this base.  */
7310   build_vbase_offset_vtbl_entries (binfo, vid);
7311   /* Add the vcall entries for this base.  */
7312   build_vcall_offset_vtbl_entries (binfo, vid);
7313 }
7314
7315 /* Returns the initializers for the vbase offset entries in the vtable
7316    for BINFO (which is part of the class hierarchy dominated by T), in
7317    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7318    where the next vbase offset will go.  */
7319
7320 static void
7321 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7322 {
7323   tree vbase;
7324   tree t;
7325   tree non_primary_binfo;
7326
7327   /* If there are no virtual baseclasses, then there is nothing to
7328      do.  */
7329   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7330     return;
7331
7332   t = vid->derived;
7333
7334   /* We might be a primary base class.  Go up the inheritance hierarchy
7335      until we find the most derived class of which we are a primary base:
7336      it is the offset of that which we need to use.  */
7337   non_primary_binfo = binfo;
7338   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7339     {
7340       tree b;
7341
7342       /* If we have reached a virtual base, then it must be a primary
7343          base (possibly multi-level) of vid->binfo, or we wouldn't
7344          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7345          might be a lost primary, so just skip down to vid->binfo.  */
7346       if (BINFO_VIRTUAL_P (non_primary_binfo))
7347         {
7348           non_primary_binfo = vid->binfo;
7349           break;
7350         }
7351
7352       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7353       if (get_primary_binfo (b) != non_primary_binfo)
7354         break;
7355       non_primary_binfo = b;
7356     }
7357
7358   /* Go through the virtual bases, adding the offsets.  */
7359   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7360        vbase;
7361        vbase = TREE_CHAIN (vbase))
7362     {
7363       tree b;
7364       tree delta;
7365
7366       if (!BINFO_VIRTUAL_P (vbase))
7367         continue;
7368
7369       /* Find the instance of this virtual base in the complete
7370          object.  */
7371       b = copied_binfo (vbase, binfo);
7372
7373       /* If we've already got an offset for this virtual base, we
7374          don't need another one.  */
7375       if (BINFO_VTABLE_PATH_MARKED (b))
7376         continue;
7377       BINFO_VTABLE_PATH_MARKED (b) = 1;
7378
7379       /* Figure out where we can find this vbase offset.  */
7380       delta = size_binop (MULT_EXPR,
7381                           vid->index,
7382                           convert (ssizetype,
7383                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7384       if (vid->primary_vtbl_p)
7385         BINFO_VPTR_FIELD (b) = delta;
7386
7387       if (binfo != TYPE_BINFO (t))
7388         /* The vbase offset had better be the same.  */
7389         gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
7390
7391       /* The next vbase will come at a more negative offset.  */
7392       vid->index = size_binop (MINUS_EXPR, vid->index,
7393                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7394
7395       /* The initializer is the delta from BINFO to this virtual base.
7396          The vbase offsets go in reverse inheritance-graph order, and
7397          we are walking in inheritance graph order so these end up in
7398          the right order.  */
7399       delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7400
7401       *vid->last_init
7402         = build_tree_list (NULL_TREE,
7403                            fold (build1 (NOP_EXPR,
7404                                          vtable_entry_type,
7405                                          delta)));
7406       vid->last_init = &TREE_CHAIN (*vid->last_init);
7407     }
7408 }
7409
7410 /* Adds the initializers for the vcall offset entries in the vtable
7411    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7412    to VID->INITS.  */
7413
7414 static void
7415 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7416 {
7417   /* We only need these entries if this base is a virtual base.  We
7418      compute the indices -- but do not add to the vtable -- when
7419      building the main vtable for a class.  */
7420   if (BINFO_VIRTUAL_P (binfo) || binfo == TYPE_BINFO (vid->derived))
7421     {
7422       /* We need a vcall offset for each of the virtual functions in this
7423          vtable.  For example:
7424
7425            class A { virtual void f (); };
7426            class B1 : virtual public A { virtual void f (); };
7427            class B2 : virtual public A { virtual void f (); };
7428            class C: public B1, public B2 { virtual void f (); };
7429
7430          A C object has a primary base of B1, which has a primary base of A.  A
7431          C also has a secondary base of B2, which no longer has a primary base
7432          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7433          A, which will adjust the A* to a B2* to call f.  We have no way of
7434          knowing what (or even whether) this offset will be when we define B2,
7435          so we store this "vcall offset" in the A sub-vtable and look it up in
7436          a "virtual thunk" for B2::f.
7437
7438          We need entries for all the functions in our primary vtable and
7439          in our non-virtual bases' secondary vtables.  */
7440       vid->vbase = binfo;
7441       /* If we are just computing the vcall indices -- but do not need
7442          the actual entries -- not that.  */
7443       if (!BINFO_VIRTUAL_P (binfo))
7444         vid->generate_vcall_entries = false;
7445       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7446       add_vcall_offset_vtbl_entries_r (binfo, vid);
7447     }
7448 }
7449
7450 /* Build vcall offsets, starting with those for BINFO.  */
7451
7452 static void
7453 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7454 {
7455   int i;
7456   tree primary_binfo;
7457   tree base_binfo;
7458
7459   /* Don't walk into virtual bases -- except, of course, for the
7460      virtual base for which we are building vcall offsets.  Any
7461      primary virtual base will have already had its offsets generated
7462      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7463   if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
7464     return;
7465
7466   /* If BINFO has a primary base, process it first.  */
7467   primary_binfo = get_primary_binfo (binfo);
7468   if (primary_binfo)
7469     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7470
7471   /* Add BINFO itself to the list.  */
7472   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7473
7474   /* Scan the non-primary bases of BINFO.  */
7475   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7476     if (base_binfo != primary_binfo)
7477       add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7478 }
7479
7480 /* Called from build_vcall_offset_vtbl_entries_r.  */
7481
7482 static void
7483 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7484 {
7485   /* Make entries for the rest of the virtuals.  */
7486   if (abi_version_at_least (2))
7487     {
7488       tree orig_fn;
7489
7490       /* The ABI requires that the methods be processed in declaration
7491          order.  G++ 3.2 used the order in the vtable.  */
7492       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7493            orig_fn;
7494            orig_fn = TREE_CHAIN (orig_fn))
7495         if (DECL_VINDEX (orig_fn))
7496           add_vcall_offset (orig_fn, binfo, vid);
7497     }
7498   else
7499     {
7500       tree derived_virtuals;
7501       tree base_virtuals;
7502       tree orig_virtuals;
7503       /* If BINFO is a primary base, the most derived class which has
7504          BINFO as a primary base; otherwise, just BINFO.  */
7505       tree non_primary_binfo;
7506
7507       /* We might be a primary base class.  Go up the inheritance hierarchy
7508          until we find the most derived class of which we are a primary base:
7509          it is the BINFO_VIRTUALS there that we need to consider.  */
7510       non_primary_binfo = binfo;
7511       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7512         {
7513           tree b;
7514
7515           /* If we have reached a virtual base, then it must be vid->vbase,
7516              because we ignore other virtual bases in
7517              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7518              base (possibly multi-level) of vid->binfo, or we wouldn't
7519              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7520              might be a lost primary, so just skip down to vid->binfo.  */
7521           if (BINFO_VIRTUAL_P (non_primary_binfo))
7522             {
7523               gcc_assert (non_primary_binfo == vid->vbase);
7524               non_primary_binfo = vid->binfo;
7525               break;
7526             }
7527
7528           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7529           if (get_primary_binfo (b) != non_primary_binfo)
7530             break;
7531           non_primary_binfo = b;
7532         }
7533
7534       if (vid->ctor_vtbl_p)
7535         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7536            where rtti_binfo is the most derived type.  */
7537         non_primary_binfo
7538           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7539
7540       for (base_virtuals = BINFO_VIRTUALS (binfo),
7541              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7542              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7543            base_virtuals;
7544            base_virtuals = TREE_CHAIN (base_virtuals),
7545              derived_virtuals = TREE_CHAIN (derived_virtuals),
7546              orig_virtuals = TREE_CHAIN (orig_virtuals))
7547         {
7548           tree orig_fn;
7549
7550           /* Find the declaration that originally caused this function to
7551              be present in BINFO_TYPE (binfo).  */
7552           orig_fn = BV_FN (orig_virtuals);
7553
7554           /* When processing BINFO, we only want to generate vcall slots for
7555              function slots introduced in BINFO.  So don't try to generate
7556              one if the function isn't even defined in BINFO.  */
7557           if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
7558             continue;
7559
7560           add_vcall_offset (orig_fn, binfo, vid);
7561         }
7562     }
7563 }
7564
7565 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7566
7567 static void
7568 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7569 {
7570   size_t i;
7571   tree vcall_offset;
7572
7573   /* If there is already an entry for a function with the same
7574      signature as FN, then we do not need a second vcall offset.
7575      Check the list of functions already present in the derived
7576      class vtable.  */
7577   for (i = 0; i < VARRAY_ACTIVE_SIZE (vid->fns); ++i)
7578     {
7579       tree derived_entry;
7580
7581       derived_entry = VARRAY_TREE (vid->fns, i);
7582       if (same_signature_p (derived_entry, orig_fn)
7583           /* We only use one vcall offset for virtual destructors,
7584              even though there are two virtual table entries.  */
7585           || (DECL_DESTRUCTOR_P (derived_entry)
7586               && DECL_DESTRUCTOR_P (orig_fn)))
7587         return;
7588     }
7589
7590   /* If we are building these vcall offsets as part of building
7591      the vtable for the most derived class, remember the vcall
7592      offset.  */
7593   if (vid->binfo == TYPE_BINFO (vid->derived))
7594     {
7595       tree_pair_p elt = VEC_safe_push (tree_pair_s,
7596                                        CLASSTYPE_VCALL_INDICES (vid->derived),
7597                                        NULL);
7598       elt->purpose = orig_fn;
7599       elt->value = vid->index;
7600     }
7601
7602   /* The next vcall offset will be found at a more negative
7603      offset.  */
7604   vid->index = size_binop (MINUS_EXPR, vid->index,
7605                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7606
7607   /* Keep track of this function.  */
7608   VARRAY_PUSH_TREE (vid->fns, orig_fn);
7609
7610   if (vid->generate_vcall_entries)
7611     {
7612       tree base;
7613       tree fn;
7614
7615       /* Find the overriding function.  */
7616       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7617       if (fn == error_mark_node)
7618         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7619                                integer_zero_node);
7620       else
7621         {
7622           base = TREE_VALUE (fn);
7623
7624           /* The vbase we're working on is a primary base of
7625              vid->binfo.  But it might be a lost primary, so its
7626              BINFO_OFFSET might be wrong, so we just use the
7627              BINFO_OFFSET from vid->binfo.  */
7628           vcall_offset = size_diffop (BINFO_OFFSET (base),
7629                                       BINFO_OFFSET (vid->binfo));
7630           vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type,
7631                                        vcall_offset));
7632         }
7633       /* Add the initializer to the vtable.  */
7634       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7635       vid->last_init = &TREE_CHAIN (*vid->last_init);
7636     }
7637 }
7638
7639 /* Return vtbl initializers for the RTTI entries corresponding to the
7640    BINFO's vtable.  The RTTI entries should indicate the object given
7641    by VID->rtti_binfo.  */
7642
7643 static void
7644 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7645 {
7646   tree b;
7647   tree t;
7648   tree basetype;
7649   tree offset;
7650   tree decl;
7651   tree init;
7652
7653   basetype = BINFO_TYPE (binfo);
7654   t = BINFO_TYPE (vid->rtti_binfo);
7655
7656   /* To find the complete object, we will first convert to our most
7657      primary base, and then add the offset in the vtbl to that value.  */
7658   b = binfo;
7659   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7660          && !BINFO_LOST_PRIMARY_P (b))
7661     {
7662       tree primary_base;
7663
7664       primary_base = get_primary_binfo (b);
7665       gcc_assert (BINFO_PRIMARY_P (primary_base)
7666                   && BINFO_INHERITANCE_CHAIN (primary_base) == b);
7667       b = primary_base;
7668     }
7669   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7670
7671   /* The second entry is the address of the typeinfo object.  */
7672   if (flag_rtti)
7673     decl = build_address (get_tinfo_decl (t));
7674   else
7675     decl = integer_zero_node;
7676
7677   /* Convert the declaration to a type that can be stored in the
7678      vtable.  */
7679   init = build_nop (vfunc_ptr_type_node, decl);
7680   *vid->last_init = build_tree_list (NULL_TREE, init);
7681   vid->last_init = &TREE_CHAIN (*vid->last_init);
7682
7683   /* Add the offset-to-top entry.  It comes earlier in the vtable that
7684      the the typeinfo entry.  Convert the offset to look like a
7685      function pointer, so that we can put it in the vtable.  */
7686   init = build_nop (vfunc_ptr_type_node, offset);
7687   *vid->last_init = build_tree_list (NULL_TREE, init);
7688   vid->last_init = &TREE_CHAIN (*vid->last_init);
7689 }
7690
7691 /* Fold a OBJ_TYPE_REF expression to the address of a function.
7692    KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF).  */
7693
7694 tree
7695 cp_fold_obj_type_ref (tree ref, tree known_type)
7696 {
7697   HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
7698   HOST_WIDE_INT i = 0;
7699   tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
7700   tree fndecl;
7701
7702   while (i != index)
7703     {
7704       i += (TARGET_VTABLE_USES_DESCRIPTORS
7705             ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
7706       v = TREE_CHAIN (v);
7707     }
7708
7709   fndecl = BV_FN (v);
7710
7711 #ifdef ENABLE_CHECKING
7712   gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
7713                                   DECL_VINDEX (fndecl)));
7714 #endif
7715
7716   return build_address (fndecl);
7717 }
7718